SemaExpr.cpp revision b2f81ac583b519aa09c10e63d84e10abd13bfed7
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 "Sema.h" 15#include "clang/AST/ASTContext.h" 16#include "clang/AST/DeclObjC.h" 17#include "clang/AST/ExprCXX.h" 18#include "clang/AST/ExprObjC.h" 19#include "clang/AST/DeclTemplate.h" 20#include "clang/Lex/Preprocessor.h" 21#include "clang/Lex/LiteralSupport.h" 22#include "clang/Basic/SourceManager.h" 23#include "clang/Basic/TargetInfo.h" 24#include "clang/Parse/DeclSpec.h" 25#include "clang/Parse/Designator.h" 26#include "clang/Parse/Scope.h" 27using namespace clang; 28 29/// \brief Determine whether the use of this declaration is valid, and 30/// emit any corresponding diagnostics. 31/// 32/// This routine diagnoses various problems with referencing 33/// declarations that can occur when using a declaration. For example, 34/// it might warn if a deprecated or unavailable declaration is being 35/// used, or produce an error (and return true) if a C++0x deleted 36/// function is being used. 37/// 38/// \returns true if there was an error (this declaration cannot be 39/// referenced), false otherwise. 40bool Sema::DiagnoseUseOfDecl(NamedDecl *D, SourceLocation Loc) { 41 // See if the decl is deprecated. 42 if (D->getAttr<DeprecatedAttr>()) { 43 // Implementing deprecated stuff requires referencing deprecated 44 // stuff. Don't warn if we are implementing a deprecated 45 // construct. 46 bool isSilenced = false; 47 48 if (NamedDecl *ND = getCurFunctionOrMethodDecl()) { 49 // If this reference happens *in* a deprecated function or method, don't 50 // warn. 51 isSilenced = ND->getAttr<DeprecatedAttr>(); 52 53 // If this is an Objective-C method implementation, check to see if the 54 // method was deprecated on the declaration, not the definition. 55 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(ND)) { 56 // The semantic decl context of a ObjCMethodDecl is the 57 // ObjCImplementationDecl. 58 if (ObjCImplementationDecl *Impl 59 = dyn_cast<ObjCImplementationDecl>(MD->getParent())) { 60 61 MD = Impl->getClassInterface()->getMethod(Context, 62 MD->getSelector(), 63 MD->isInstanceMethod()); 64 isSilenced |= MD && MD->getAttr<DeprecatedAttr>(); 65 } 66 } 67 } 68 69 if (!isSilenced) 70 Diag(Loc, diag::warn_deprecated) << D->getDeclName(); 71 } 72 73 // See if this is a deleted function. 74 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 75 if (FD->isDeleted()) { 76 Diag(Loc, diag::err_deleted_function_use); 77 Diag(D->getLocation(), diag::note_unavailable_here) << true; 78 return true; 79 } 80 } 81 82 // See if the decl is unavailable 83 if (D->getAttr<UnavailableAttr>()) { 84 Diag(Loc, diag::warn_unavailable) << D->getDeclName(); 85 Diag(D->getLocation(), diag::note_unavailable_here) << 0; 86 } 87 88 return false; 89} 90 91/// DiagnoseSentinelCalls - This routine checks on method dispatch calls 92/// (and other functions in future), which have been declared with sentinel 93/// attribute. It warns if call does not have the sentinel argument. 94/// 95void Sema::DiagnoseSentinelCalls(NamedDecl *D, SourceLocation Loc, 96 Expr **Args, unsigned NumArgs) 97{ 98 const SentinelAttr *attr = D->getAttr<SentinelAttr>(); 99 if (!attr) 100 return; 101 int sentinelPos = attr->getSentinel(); 102 int nullPos = attr->getNullPos(); 103 104 // FIXME. ObjCMethodDecl and FunctionDecl need be derived from the same common 105 // base class. Then we won't be needing two versions of the same code. 106 unsigned int i = 0; 107 bool warnNotEnoughArgs = false; 108 int isMethod = 0; 109 if (ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) { 110 // skip over named parameters. 111 ObjCMethodDecl::param_iterator P, E = MD->param_end(); 112 for (P = MD->param_begin(); (P != E && i < NumArgs); ++P) { 113 if (nullPos) 114 --nullPos; 115 else 116 ++i; 117 } 118 warnNotEnoughArgs = (P != E || i >= NumArgs); 119 isMethod = 1; 120 } 121 else if (FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 122 // skip over named parameters. 123 ObjCMethodDecl::param_iterator P, E = FD->param_end(); 124 for (P = FD->param_begin(); (P != E && i < NumArgs); ++P) { 125 if (nullPos) 126 --nullPos; 127 else 128 ++i; 129 } 130 warnNotEnoughArgs = (P != E || i >= NumArgs); 131 } 132 else if (VarDecl *V = dyn_cast<VarDecl>(D)) { 133 // block or function pointer call. 134 QualType Ty = V->getType(); 135 if (Ty->isBlockPointerType() || Ty->isFunctionPointerType()) { 136 const FunctionType *FT = Ty->isFunctionPointerType() 137 ? Ty->getAsPointerType()->getPointeeType()->getAsFunctionType() 138 : Ty->getAsBlockPointerType()->getPointeeType()->getAsFunctionType(); 139 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FT)) { 140 unsigned NumArgsInProto = Proto->getNumArgs(); 141 unsigned k; 142 for (k = 0; (k != NumArgsInProto && i < NumArgs); k++) { 143 if (nullPos) 144 --nullPos; 145 else 146 ++i; 147 } 148 warnNotEnoughArgs = (k != NumArgsInProto || i >= NumArgs); 149 } 150 if (Ty->isBlockPointerType()) 151 isMethod = 2; 152 } 153 else 154 return; 155 } 156 else 157 return; 158 159 if (warnNotEnoughArgs) { 160 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 161 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod; 162 return; 163 } 164 int sentinel = i; 165 while (sentinelPos > 0 && i < NumArgs-1) { 166 --sentinelPos; 167 ++i; 168 } 169 if (sentinelPos > 0) { 170 Diag(Loc, diag::warn_not_enough_argument) << D->getDeclName(); 171 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod; 172 return; 173 } 174 while (i < NumArgs-1) { 175 ++i; 176 ++sentinel; 177 } 178 Expr *sentinelExpr = Args[sentinel]; 179 if (sentinelExpr && (!sentinelExpr->getType()->isPointerType() || 180 !sentinelExpr->isNullPointerConstant(Context))) { 181 Diag(Loc, diag::warn_missing_sentinel) << isMethod; 182 Diag(D->getLocation(), diag::note_sentinel_here) << isMethod; 183 } 184 return; 185} 186 187SourceRange Sema::getExprRange(ExprTy *E) const { 188 Expr *Ex = (Expr *)E; 189 return Ex? Ex->getSourceRange() : SourceRange(); 190} 191 192//===----------------------------------------------------------------------===// 193// Standard Promotions and Conversions 194//===----------------------------------------------------------------------===// 195 196/// DefaultFunctionArrayConversion (C99 6.3.2.1p3, C99 6.3.2.1p4). 197void Sema::DefaultFunctionArrayConversion(Expr *&E) { 198 QualType Ty = E->getType(); 199 assert(!Ty.isNull() && "DefaultFunctionArrayConversion - missing type"); 200 201 if (Ty->isFunctionType()) 202 ImpCastExprToType(E, Context.getPointerType(Ty)); 203 else if (Ty->isArrayType()) { 204 // In C90 mode, arrays only promote to pointers if the array expression is 205 // an lvalue. The relevant legalese is C90 6.2.2.1p3: "an lvalue that has 206 // type 'array of type' is converted to an expression that has type 'pointer 207 // to type'...". In C99 this was changed to: C99 6.3.2.1p3: "an expression 208 // that has type 'array of type' ...". The relevant change is "an lvalue" 209 // (C90) to "an expression" (C99). 210 // 211 // C++ 4.2p1: 212 // An lvalue or rvalue of type "array of N T" or "array of unknown bound of 213 // T" can be converted to an rvalue of type "pointer to T". 214 // 215 if (getLangOptions().C99 || getLangOptions().CPlusPlus || 216 E->isLvalue(Context) == Expr::LV_Valid) 217 ImpCastExprToType(E, Context.getArrayDecayedType(Ty)); 218 } 219} 220 221/// \brief Whether this is a promotable bitfield reference according 222/// to C99 6.3.1.1p2, bullet 2. 223/// 224/// \returns the type this bit-field will promote to, or NULL if no 225/// promotion occurs. 226static QualType isPromotableBitField(Expr *E, ASTContext &Context) { 227 FieldDecl *Field = E->getBitField(); 228 if (!Field) 229 return QualType(); 230 231 const BuiltinType *BT = Field->getType()->getAsBuiltinType(); 232 if (!BT) 233 return QualType(); 234 235 if (BT->getKind() != BuiltinType::Bool && 236 BT->getKind() != BuiltinType::Int && 237 BT->getKind() != BuiltinType::UInt) 238 return QualType(); 239 240 llvm::APSInt BitWidthAP; 241 if (!Field->getBitWidth()->isIntegerConstantExpr(BitWidthAP, Context)) 242 return QualType(); 243 244 uint64_t BitWidth = BitWidthAP.getZExtValue(); 245 uint64_t IntSize = Context.getTypeSize(Context.IntTy); 246 if (BitWidth < IntSize || 247 (Field->getType()->isSignedIntegerType() && BitWidth == IntSize)) 248 return Context.IntTy; 249 250 if (BitWidth == IntSize && Field->getType()->isUnsignedIntegerType()) 251 return Context.UnsignedIntTy; 252 253 return QualType(); 254} 255 256/// UsualUnaryConversions - Performs various conversions that are common to most 257/// operators (C99 6.3). The conversions of array and function types are 258/// sometimes surpressed. For example, the array->pointer conversion doesn't 259/// apply if the array is an argument to the sizeof or address (&) operators. 260/// In these instances, this routine should *not* be called. 261Expr *Sema::UsualUnaryConversions(Expr *&Expr) { 262 QualType Ty = Expr->getType(); 263 assert(!Ty.isNull() && "UsualUnaryConversions - missing type"); 264 265 // C99 6.3.1.1p2: 266 // 267 // The following may be used in an expression wherever an int or 268 // unsigned int may be used: 269 // - an object or expression with an integer type whose integer 270 // conversion rank is less than or equal to the rank of int 271 // and unsigned int. 272 // - A bit-field of type _Bool, int, signed int, or unsigned int. 273 // 274 // If an int can represent all values of the original type, the 275 // value is converted to an int; otherwise, it is converted to an 276 // unsigned int. These are called the integer promotions. All 277 // other types are unchanged by the integer promotions. 278 if (Ty->isPromotableIntegerType()) { 279 ImpCastExprToType(Expr, Context.IntTy); 280 return Expr; 281 } else { 282 QualType T = isPromotableBitField(Expr, Context); 283 if (!T.isNull()) { 284 ImpCastExprToType(Expr, T); 285 return Expr; 286 } 287 } 288 289 DefaultFunctionArrayConversion(Expr); 290 return Expr; 291} 292 293/// DefaultArgumentPromotion (C99 6.5.2.2p6). Used for function calls that 294/// do not have a prototype. Arguments that have type float are promoted to 295/// double. All other argument types are converted by UsualUnaryConversions(). 296void Sema::DefaultArgumentPromotion(Expr *&Expr) { 297 QualType Ty = Expr->getType(); 298 assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type"); 299 300 // If this is a 'float' (CVR qualified or typedef) promote to double. 301 if (const BuiltinType *BT = Ty->getAsBuiltinType()) 302 if (BT->getKind() == BuiltinType::Float) 303 return ImpCastExprToType(Expr, Context.DoubleTy); 304 305 UsualUnaryConversions(Expr); 306} 307 308/// DefaultVariadicArgumentPromotion - Like DefaultArgumentPromotion, but 309/// will warn if the resulting type is not a POD type, and rejects ObjC 310/// interfaces passed by value. This returns true if the argument type is 311/// completely illegal. 312bool Sema::DefaultVariadicArgumentPromotion(Expr *&Expr, VariadicCallType CT) { 313 DefaultArgumentPromotion(Expr); 314 315 if (Expr->getType()->isObjCInterfaceType()) { 316 Diag(Expr->getLocStart(), 317 diag::err_cannot_pass_objc_interface_to_vararg) 318 << Expr->getType() << CT; 319 return true; 320 } 321 322 if (!Expr->getType()->isPODType()) 323 Diag(Expr->getLocStart(), diag::warn_cannot_pass_non_pod_arg_to_vararg) 324 << Expr->getType() << CT; 325 326 return false; 327} 328 329 330/// UsualArithmeticConversions - Performs various conversions that are common to 331/// binary operators (C99 6.3.1.8). If both operands aren't arithmetic, this 332/// routine returns the first non-arithmetic type found. The client is 333/// responsible for emitting appropriate error diagnostics. 334/// FIXME: verify the conversion rules for "complex int" are consistent with 335/// GCC. 336QualType Sema::UsualArithmeticConversions(Expr *&lhsExpr, Expr *&rhsExpr, 337 bool isCompAssign) { 338 if (!isCompAssign) 339 UsualUnaryConversions(lhsExpr); 340 341 UsualUnaryConversions(rhsExpr); 342 343 // For conversion purposes, we ignore any qualifiers. 344 // For example, "const float" and "float" are equivalent. 345 QualType lhs = 346 Context.getCanonicalType(lhsExpr->getType()).getUnqualifiedType(); 347 QualType rhs = 348 Context.getCanonicalType(rhsExpr->getType()).getUnqualifiedType(); 349 350 // If both types are identical, no conversion is needed. 351 if (lhs == rhs) 352 return lhs; 353 354 // If either side is a non-arithmetic type (e.g. a pointer), we are done. 355 // The caller can deal with this (e.g. pointer + int). 356 if (!lhs->isArithmeticType() || !rhs->isArithmeticType()) 357 return lhs; 358 359 // Perform bitfield promotions. 360 QualType LHSBitfieldPromoteTy = isPromotableBitField(lhsExpr, Context); 361 if (!LHSBitfieldPromoteTy.isNull()) 362 lhs = LHSBitfieldPromoteTy; 363 QualType RHSBitfieldPromoteTy = isPromotableBitField(rhsExpr, Context); 364 if (!RHSBitfieldPromoteTy.isNull()) 365 rhs = RHSBitfieldPromoteTy; 366 367 QualType destType = UsualArithmeticConversionsType(lhs, rhs); 368 if (!isCompAssign) 369 ImpCastExprToType(lhsExpr, destType); 370 ImpCastExprToType(rhsExpr, destType); 371 return destType; 372} 373 374QualType Sema::UsualArithmeticConversionsType(QualType lhs, QualType rhs) { 375 // Perform the usual unary conversions. We do this early so that 376 // integral promotions to "int" can allow us to exit early, in the 377 // lhs == rhs check. Also, for conversion purposes, we ignore any 378 // qualifiers. For example, "const float" and "float" are 379 // equivalent. 380 if (lhs->isPromotableIntegerType()) 381 lhs = Context.IntTy; 382 else 383 lhs = lhs.getUnqualifiedType(); 384 if (rhs->isPromotableIntegerType()) 385 rhs = Context.IntTy; 386 else 387 rhs = rhs.getUnqualifiedType(); 388 389 // If both types are identical, no conversion is needed. 390 if (lhs == rhs) 391 return lhs; 392 393 // If either side is a non-arithmetic type (e.g. a pointer), we are done. 394 // The caller can deal with this (e.g. pointer + int). 395 if (!lhs->isArithmeticType() || !rhs->isArithmeticType()) 396 return lhs; 397 398 // At this point, we have two different arithmetic types. 399 400 // Handle complex types first (C99 6.3.1.8p1). 401 if (lhs->isComplexType() || rhs->isComplexType()) { 402 // if we have an integer operand, the result is the complex type. 403 if (rhs->isIntegerType() || rhs->isComplexIntegerType()) { 404 // convert the rhs to the lhs complex type. 405 return lhs; 406 } 407 if (lhs->isIntegerType() || lhs->isComplexIntegerType()) { 408 // convert the lhs to the rhs complex type. 409 return rhs; 410 } 411 // This handles complex/complex, complex/float, or float/complex. 412 // When both operands are complex, the shorter operand is converted to the 413 // type of the longer, and that is the type of the result. This corresponds 414 // to what is done when combining two real floating-point operands. 415 // The fun begins when size promotion occur across type domains. 416 // From H&S 6.3.4: When one operand is complex and the other is a real 417 // floating-point type, the less precise type is converted, within it's 418 // real or complex domain, to the precision of the other type. For example, 419 // when combining a "long double" with a "double _Complex", the 420 // "double _Complex" is promoted to "long double _Complex". 421 int result = Context.getFloatingTypeOrder(lhs, rhs); 422 423 if (result > 0) { // The left side is bigger, convert rhs. 424 rhs = Context.getFloatingTypeOfSizeWithinDomain(lhs, rhs); 425 } else if (result < 0) { // The right side is bigger, convert lhs. 426 lhs = Context.getFloatingTypeOfSizeWithinDomain(rhs, lhs); 427 } 428 // At this point, lhs and rhs have the same rank/size. Now, make sure the 429 // domains match. This is a requirement for our implementation, C99 430 // does not require this promotion. 431 if (lhs != rhs) { // Domains don't match, we have complex/float mix. 432 if (lhs->isRealFloatingType()) { // handle "double, _Complex double". 433 return rhs; 434 } else { // handle "_Complex double, double". 435 return lhs; 436 } 437 } 438 return lhs; // The domain/size match exactly. 439 } 440 // Now handle "real" floating types (i.e. float, double, long double). 441 if (lhs->isRealFloatingType() || rhs->isRealFloatingType()) { 442 // if we have an integer operand, the result is the real floating type. 443 if (rhs->isIntegerType()) { 444 // convert rhs to the lhs floating point type. 445 return lhs; 446 } 447 if (rhs->isComplexIntegerType()) { 448 // convert rhs to the complex floating point type. 449 return Context.getComplexType(lhs); 450 } 451 if (lhs->isIntegerType()) { 452 // convert lhs to the rhs floating point type. 453 return rhs; 454 } 455 if (lhs->isComplexIntegerType()) { 456 // convert lhs to the complex floating point type. 457 return Context.getComplexType(rhs); 458 } 459 // We have two real floating types, float/complex combos were handled above. 460 // Convert the smaller operand to the bigger result. 461 int result = Context.getFloatingTypeOrder(lhs, rhs); 462 if (result > 0) // convert the rhs 463 return lhs; 464 assert(result < 0 && "illegal float comparison"); 465 return rhs; // convert the lhs 466 } 467 if (lhs->isComplexIntegerType() || rhs->isComplexIntegerType()) { 468 // Handle GCC complex int extension. 469 const ComplexType *lhsComplexInt = lhs->getAsComplexIntegerType(); 470 const ComplexType *rhsComplexInt = rhs->getAsComplexIntegerType(); 471 472 if (lhsComplexInt && rhsComplexInt) { 473 if (Context.getIntegerTypeOrder(lhsComplexInt->getElementType(), 474 rhsComplexInt->getElementType()) >= 0) 475 return lhs; // convert the rhs 476 return rhs; 477 } else if (lhsComplexInt && rhs->isIntegerType()) { 478 // convert the rhs to the lhs complex type. 479 return lhs; 480 } else if (rhsComplexInt && lhs->isIntegerType()) { 481 // convert the lhs to the rhs complex type. 482 return rhs; 483 } 484 } 485 // Finally, we have two differing integer types. 486 // The rules for this case are in C99 6.3.1.8 487 int compare = Context.getIntegerTypeOrder(lhs, rhs); 488 bool lhsSigned = lhs->isSignedIntegerType(), 489 rhsSigned = rhs->isSignedIntegerType(); 490 QualType destType; 491 if (lhsSigned == rhsSigned) { 492 // Same signedness; use the higher-ranked type 493 destType = compare >= 0 ? lhs : rhs; 494 } else if (compare != (lhsSigned ? 1 : -1)) { 495 // The unsigned type has greater than or equal rank to the 496 // signed type, so use the unsigned type 497 destType = lhsSigned ? rhs : lhs; 498 } else if (Context.getIntWidth(lhs) != Context.getIntWidth(rhs)) { 499 // The two types are different widths; if we are here, that 500 // means the signed type is larger than the unsigned type, so 501 // use the signed type. 502 destType = lhsSigned ? lhs : rhs; 503 } else { 504 // The signed type is higher-ranked than the unsigned type, 505 // but isn't actually any bigger (like unsigned int and long 506 // on most 32-bit systems). Use the unsigned type corresponding 507 // to the signed type. 508 destType = Context.getCorrespondingUnsignedType(lhsSigned ? lhs : rhs); 509 } 510 return destType; 511} 512 513//===----------------------------------------------------------------------===// 514// Semantic Analysis for various Expression Types 515//===----------------------------------------------------------------------===// 516 517 518/// ActOnStringLiteral - The specified tokens were lexed as pasted string 519/// fragments (e.g. "foo" "bar" L"baz"). The result string has to handle string 520/// concatenation ([C99 5.1.1.2, translation phase #6]), so it may come from 521/// multiple tokens. However, the common case is that StringToks points to one 522/// string. 523/// 524Action::OwningExprResult 525Sema::ActOnStringLiteral(const Token *StringToks, unsigned NumStringToks) { 526 assert(NumStringToks && "Must have at least one string!"); 527 528 StringLiteralParser Literal(StringToks, NumStringToks, PP); 529 if (Literal.hadError) 530 return ExprError(); 531 532 llvm::SmallVector<SourceLocation, 4> StringTokLocs; 533 for (unsigned i = 0; i != NumStringToks; ++i) 534 StringTokLocs.push_back(StringToks[i].getLocation()); 535 536 QualType StrTy = Context.CharTy; 537 if (Literal.AnyWide) StrTy = Context.getWCharType(); 538 if (Literal.Pascal) StrTy = Context.UnsignedCharTy; 539 540 // A C++ string literal has a const-qualified element type (C++ 2.13.4p1). 541 if (getLangOptions().CPlusPlus) 542 StrTy.addConst(); 543 544 // Get an array type for the string, according to C99 6.4.5. This includes 545 // the nul terminator character as well as the string length for pascal 546 // strings. 547 StrTy = Context.getConstantArrayType(StrTy, 548 llvm::APInt(32, Literal.GetNumStringChars()+1), 549 ArrayType::Normal, 0); 550 551 // Pass &StringTokLocs[0], StringTokLocs.size() to factory! 552 return Owned(StringLiteral::Create(Context, Literal.GetString(), 553 Literal.GetStringLength(), 554 Literal.AnyWide, StrTy, 555 &StringTokLocs[0], 556 StringTokLocs.size())); 557} 558 559/// ShouldSnapshotBlockValueReference - Return true if a reference inside of 560/// CurBlock to VD should cause it to be snapshotted (as we do for auto 561/// variables defined outside the block) or false if this is not needed (e.g. 562/// for values inside the block or for globals). 563/// 564/// This also keeps the 'hasBlockDeclRefExprs' in the BlockSemaInfo records 565/// up-to-date. 566/// 567static bool ShouldSnapshotBlockValueReference(BlockSemaInfo *CurBlock, 568 ValueDecl *VD) { 569 // If the value is defined inside the block, we couldn't snapshot it even if 570 // we wanted to. 571 if (CurBlock->TheDecl == VD->getDeclContext()) 572 return false; 573 574 // If this is an enum constant or function, it is constant, don't snapshot. 575 if (isa<EnumConstantDecl>(VD) || isa<FunctionDecl>(VD)) 576 return false; 577 578 // If this is a reference to an extern, static, or global variable, no need to 579 // snapshot it. 580 // FIXME: What about 'const' variables in C++? 581 if (const VarDecl *Var = dyn_cast<VarDecl>(VD)) 582 if (!Var->hasLocalStorage()) 583 return false; 584 585 // Blocks that have these can't be constant. 586 CurBlock->hasBlockDeclRefExprs = true; 587 588 // If we have nested blocks, the decl may be declared in an outer block (in 589 // which case that outer block doesn't get "hasBlockDeclRefExprs") or it may 590 // be defined outside all of the current blocks (in which case the blocks do 591 // all get the bit). Walk the nesting chain. 592 for (BlockSemaInfo *NextBlock = CurBlock->PrevBlockInfo; NextBlock; 593 NextBlock = NextBlock->PrevBlockInfo) { 594 // If we found the defining block for the variable, don't mark the block as 595 // having a reference outside it. 596 if (NextBlock->TheDecl == VD->getDeclContext()) 597 break; 598 599 // Otherwise, the DeclRef from the inner block causes the outer one to need 600 // a snapshot as well. 601 NextBlock->hasBlockDeclRefExprs = true; 602 } 603 604 return true; 605} 606 607 608 609/// ActOnIdentifierExpr - The parser read an identifier in expression context, 610/// validate it per-C99 6.5.1. HasTrailingLParen indicates whether this 611/// identifier is used in a function call context. 612/// SS is only used for a C++ qualified-id (foo::bar) to indicate the 613/// class or namespace that the identifier must be a member of. 614Sema::OwningExprResult Sema::ActOnIdentifierExpr(Scope *S, SourceLocation Loc, 615 IdentifierInfo &II, 616 bool HasTrailingLParen, 617 const CXXScopeSpec *SS, 618 bool isAddressOfOperand) { 619 return ActOnDeclarationNameExpr(S, Loc, &II, HasTrailingLParen, SS, 620 isAddressOfOperand); 621} 622 623/// BuildDeclRefExpr - Build either a DeclRefExpr or a 624/// QualifiedDeclRefExpr based on whether or not SS is a 625/// nested-name-specifier. 626DeclRefExpr * 627Sema::BuildDeclRefExpr(NamedDecl *D, QualType Ty, SourceLocation Loc, 628 bool TypeDependent, bool ValueDependent, 629 const CXXScopeSpec *SS) { 630 if (SS && !SS->isEmpty()) { 631 return new (Context) QualifiedDeclRefExpr(D, Ty, Loc, TypeDependent, 632 ValueDependent, SS->getRange(), 633 static_cast<NestedNameSpecifier *>(SS->getScopeRep())); 634 } else 635 return new (Context) DeclRefExpr(D, Ty, Loc, TypeDependent, ValueDependent); 636} 637 638/// getObjectForAnonymousRecordDecl - Retrieve the (unnamed) field or 639/// variable corresponding to the anonymous union or struct whose type 640/// is Record. 641static Decl *getObjectForAnonymousRecordDecl(ASTContext &Context, 642 RecordDecl *Record) { 643 assert(Record->isAnonymousStructOrUnion() && 644 "Record must be an anonymous struct or union!"); 645 646 // FIXME: Once Decls are directly linked together, this will be an O(1) 647 // operation rather than a slow walk through DeclContext's vector (which 648 // itself will be eliminated). DeclGroups might make this even better. 649 DeclContext *Ctx = Record->getDeclContext(); 650 for (DeclContext::decl_iterator D = Ctx->decls_begin(Context), 651 DEnd = Ctx->decls_end(Context); 652 D != DEnd; ++D) { 653 if (*D == Record) { 654 // The object for the anonymous struct/union directly 655 // follows its type in the list of declarations. 656 ++D; 657 assert(D != DEnd && "Missing object for anonymous record"); 658 assert(!cast<NamedDecl>(*D)->getDeclName() && "Decl should be unnamed"); 659 return *D; 660 } 661 } 662 663 assert(false && "Missing object for anonymous record"); 664 return 0; 665} 666 667/// \brief Given a field that represents a member of an anonymous 668/// struct/union, build the path from that field's context to the 669/// actual member. 670/// 671/// Construct the sequence of field member references we'll have to 672/// perform to get to the field in the anonymous union/struct. The 673/// list of members is built from the field outward, so traverse it 674/// backwards to go from an object in the current context to the field 675/// we found. 676/// 677/// \returns The variable from which the field access should begin, 678/// for an anonymous struct/union that is not a member of another 679/// class. Otherwise, returns NULL. 680VarDecl *Sema::BuildAnonymousStructUnionMemberPath(FieldDecl *Field, 681 llvm::SmallVectorImpl<FieldDecl *> &Path) { 682 assert(Field->getDeclContext()->isRecord() && 683 cast<RecordDecl>(Field->getDeclContext())->isAnonymousStructOrUnion() 684 && "Field must be stored inside an anonymous struct or union"); 685 686 Path.push_back(Field); 687 VarDecl *BaseObject = 0; 688 DeclContext *Ctx = Field->getDeclContext(); 689 do { 690 RecordDecl *Record = cast<RecordDecl>(Ctx); 691 Decl *AnonObject = getObjectForAnonymousRecordDecl(Context, Record); 692 if (FieldDecl *AnonField = dyn_cast<FieldDecl>(AnonObject)) 693 Path.push_back(AnonField); 694 else { 695 BaseObject = cast<VarDecl>(AnonObject); 696 break; 697 } 698 Ctx = Ctx->getParent(); 699 } while (Ctx->isRecord() && 700 cast<RecordDecl>(Ctx)->isAnonymousStructOrUnion()); 701 702 return BaseObject; 703} 704 705Sema::OwningExprResult 706Sema::BuildAnonymousStructUnionMemberReference(SourceLocation Loc, 707 FieldDecl *Field, 708 Expr *BaseObjectExpr, 709 SourceLocation OpLoc) { 710 llvm::SmallVector<FieldDecl *, 4> AnonFields; 711 VarDecl *BaseObject = BuildAnonymousStructUnionMemberPath(Field, 712 AnonFields); 713 714 // Build the expression that refers to the base object, from 715 // which we will build a sequence of member references to each 716 // of the anonymous union objects and, eventually, the field we 717 // found via name lookup. 718 bool BaseObjectIsPointer = false; 719 unsigned ExtraQuals = 0; 720 if (BaseObject) { 721 // BaseObject is an anonymous struct/union variable (and is, 722 // therefore, not part of another non-anonymous record). 723 if (BaseObjectExpr) BaseObjectExpr->Destroy(Context); 724 BaseObjectExpr = new (Context) DeclRefExpr(BaseObject,BaseObject->getType(), 725 SourceLocation()); 726 ExtraQuals 727 = Context.getCanonicalType(BaseObject->getType()).getCVRQualifiers(); 728 } else if (BaseObjectExpr) { 729 // The caller provided the base object expression. Determine 730 // whether its a pointer and whether it adds any qualifiers to the 731 // anonymous struct/union fields we're looking into. 732 QualType ObjectType = BaseObjectExpr->getType(); 733 if (const PointerType *ObjectPtr = ObjectType->getAsPointerType()) { 734 BaseObjectIsPointer = true; 735 ObjectType = ObjectPtr->getPointeeType(); 736 } 737 ExtraQuals = Context.getCanonicalType(ObjectType).getCVRQualifiers(); 738 } else { 739 // We've found a member of an anonymous struct/union that is 740 // inside a non-anonymous struct/union, so in a well-formed 741 // program our base object expression is "this". 742 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) { 743 if (!MD->isStatic()) { 744 QualType AnonFieldType 745 = Context.getTagDeclType( 746 cast<RecordDecl>(AnonFields.back()->getDeclContext())); 747 QualType ThisType = Context.getTagDeclType(MD->getParent()); 748 if ((Context.getCanonicalType(AnonFieldType) 749 == Context.getCanonicalType(ThisType)) || 750 IsDerivedFrom(ThisType, AnonFieldType)) { 751 // Our base object expression is "this". 752 BaseObjectExpr = new (Context) CXXThisExpr(SourceLocation(), 753 MD->getThisType(Context)); 754 BaseObjectIsPointer = true; 755 } 756 } else { 757 return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method) 758 << Field->getDeclName()); 759 } 760 ExtraQuals = MD->getTypeQualifiers(); 761 } 762 763 if (!BaseObjectExpr) 764 return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use) 765 << Field->getDeclName()); 766 } 767 768 // Build the implicit member references to the field of the 769 // anonymous struct/union. 770 Expr *Result = BaseObjectExpr; 771 for (llvm::SmallVector<FieldDecl *, 4>::reverse_iterator 772 FI = AnonFields.rbegin(), FIEnd = AnonFields.rend(); 773 FI != FIEnd; ++FI) { 774 QualType MemberType = (*FI)->getType(); 775 if (!(*FI)->isMutable()) { 776 unsigned combinedQualifiers 777 = MemberType.getCVRQualifiers() | ExtraQuals; 778 MemberType = MemberType.getQualifiedType(combinedQualifiers); 779 } 780 Result = new (Context) MemberExpr(Result, BaseObjectIsPointer, *FI, 781 OpLoc, MemberType); 782 BaseObjectIsPointer = false; 783 ExtraQuals = Context.getCanonicalType(MemberType).getCVRQualifiers(); 784 } 785 786 return Owned(Result); 787} 788 789/// ActOnDeclarationNameExpr - The parser has read some kind of name 790/// (e.g., a C++ id-expression (C++ [expr.prim]p1)). This routine 791/// performs lookup on that name and returns an expression that refers 792/// to that name. This routine isn't directly called from the parser, 793/// because the parser doesn't know about DeclarationName. Rather, 794/// this routine is called by ActOnIdentifierExpr, 795/// ActOnOperatorFunctionIdExpr, and ActOnConversionFunctionExpr, 796/// which form the DeclarationName from the corresponding syntactic 797/// forms. 798/// 799/// HasTrailingLParen indicates whether this identifier is used in a 800/// function call context. LookupCtx is only used for a C++ 801/// qualified-id (foo::bar) to indicate the class or namespace that 802/// the identifier must be a member of. 803/// 804/// isAddressOfOperand means that this expression is the direct operand 805/// of an address-of operator. This matters because this is the only 806/// situation where a qualified name referencing a non-static member may 807/// appear outside a member function of this class. 808Sema::OwningExprResult 809Sema::ActOnDeclarationNameExpr(Scope *S, SourceLocation Loc, 810 DeclarationName Name, bool HasTrailingLParen, 811 const CXXScopeSpec *SS, 812 bool isAddressOfOperand) { 813 // Could be enum-constant, value decl, instance variable, etc. 814 if (SS && SS->isInvalid()) 815 return ExprError(); 816 817 // C++ [temp.dep.expr]p3: 818 // An id-expression is type-dependent if it contains: 819 // -- a nested-name-specifier that contains a class-name that 820 // names a dependent type. 821 if (SS && isDependentScopeSpecifier(*SS)) { 822 return Owned(new (Context) UnresolvedDeclRefExpr(Name, Context.DependentTy, 823 Loc, SS->getRange(), 824 static_cast<NestedNameSpecifier *>(SS->getScopeRep()))); 825 } 826 827 LookupResult Lookup = LookupParsedName(S, SS, Name, LookupOrdinaryName, 828 false, true, Loc); 829 830 if (Lookup.isAmbiguous()) { 831 DiagnoseAmbiguousLookup(Lookup, Name, Loc, 832 SS && SS->isSet() ? SS->getRange() 833 : SourceRange()); 834 return ExprError(); 835 } 836 837 NamedDecl *D = Lookup.getAsDecl(); 838 839 // If this reference is in an Objective-C method, then ivar lookup happens as 840 // well. 841 IdentifierInfo *II = Name.getAsIdentifierInfo(); 842 if (II && getCurMethodDecl()) { 843 // There are two cases to handle here. 1) scoped lookup could have failed, 844 // in which case we should look for an ivar. 2) scoped lookup could have 845 // found a decl, but that decl is outside the current instance method (i.e. 846 // a global variable). In these two cases, we do a lookup for an ivar with 847 // this name, if the lookup sucedes, we replace it our current decl. 848 if (D == 0 || D->isDefinedOutsideFunctionOrMethod()) { 849 ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface(); 850 ObjCInterfaceDecl *ClassDeclared; 851 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(Context, II, 852 ClassDeclared)) { 853 // Check if referencing a field with __attribute__((deprecated)). 854 if (DiagnoseUseOfDecl(IV, Loc)) 855 return ExprError(); 856 857 // If we're referencing an invalid decl, just return this as a silent 858 // error node. The error diagnostic was already emitted on the decl. 859 if (IV->isInvalidDecl()) 860 return ExprError(); 861 862 bool IsClsMethod = getCurMethodDecl()->isClassMethod(); 863 // If a class method attemps to use a free standing ivar, this is 864 // an error. 865 if (IsClsMethod && D && !D->isDefinedOutsideFunctionOrMethod()) 866 return ExprError(Diag(Loc, diag::error_ivar_use_in_class_method) 867 << IV->getDeclName()); 868 // If a class method uses a global variable, even if an ivar with 869 // same name exists, use the global. 870 if (!IsClsMethod) { 871 if (IV->getAccessControl() == ObjCIvarDecl::Private && 872 ClassDeclared != IFace) 873 Diag(Loc, diag::error_private_ivar_access) << IV->getDeclName(); 874 // FIXME: This should use a new expr for a direct reference, don't 875 // turn this into Self->ivar, just return a BareIVarExpr or something. 876 IdentifierInfo &II = Context.Idents.get("self"); 877 OwningExprResult SelfExpr = ActOnIdentifierExpr(S, Loc, II, false); 878 return Owned(new (Context) 879 ObjCIvarRefExpr(IV, IV->getType(), Loc, 880 SelfExpr.takeAs<Expr>(), true, true)); 881 } 882 } 883 } 884 else if (getCurMethodDecl()->isInstanceMethod()) { 885 // We should warn if a local variable hides an ivar. 886 ObjCInterfaceDecl *IFace = getCurMethodDecl()->getClassInterface(); 887 ObjCInterfaceDecl *ClassDeclared; 888 if (ObjCIvarDecl *IV = IFace->lookupInstanceVariable(Context, II, 889 ClassDeclared)) { 890 if (IV->getAccessControl() != ObjCIvarDecl::Private || 891 IFace == ClassDeclared) 892 Diag(Loc, diag::warn_ivar_use_hidden) << IV->getDeclName(); 893 } 894 } 895 // Needed to implement property "super.method" notation. 896 if (D == 0 && II->isStr("super")) { 897 QualType T; 898 899 if (getCurMethodDecl()->isInstanceMethod()) 900 T = Context.getPointerType(Context.getObjCInterfaceType( 901 getCurMethodDecl()->getClassInterface())); 902 else 903 T = Context.getObjCClassType(); 904 return Owned(new (Context) ObjCSuperExpr(Loc, T)); 905 } 906 } 907 908 // Determine whether this name might be a candidate for 909 // argument-dependent lookup. 910 bool ADL = getLangOptions().CPlusPlus && (!SS || !SS->isSet()) && 911 HasTrailingLParen; 912 913 if (ADL && D == 0) { 914 // We've seen something of the form 915 // 916 // identifier( 917 // 918 // and we did not find any entity by the name 919 // "identifier". However, this identifier is still subject to 920 // argument-dependent lookup, so keep track of the name. 921 return Owned(new (Context) UnresolvedFunctionNameExpr(Name, 922 Context.OverloadTy, 923 Loc)); 924 } 925 926 if (D == 0) { 927 // Otherwise, this could be an implicitly declared function reference (legal 928 // in C90, extension in C99). 929 if (HasTrailingLParen && II && 930 !getLangOptions().CPlusPlus) // Not in C++. 931 D = ImplicitlyDefineFunction(Loc, *II, S); 932 else { 933 // If this name wasn't predeclared and if this is not a function call, 934 // diagnose the problem. 935 if (SS && !SS->isEmpty()) 936 return ExprError(Diag(Loc, diag::err_typecheck_no_member) 937 << Name << SS->getRange()); 938 else if (Name.getNameKind() == DeclarationName::CXXOperatorName || 939 Name.getNameKind() == DeclarationName::CXXConversionFunctionName) 940 return ExprError(Diag(Loc, diag::err_undeclared_use) 941 << Name.getAsString()); 942 else 943 return ExprError(Diag(Loc, diag::err_undeclared_var_use) << Name); 944 } 945 } 946 947 // If this is an expression of the form &Class::member, don't build an 948 // implicit member ref, because we want a pointer to the member in general, 949 // not any specific instance's member. 950 if (isAddressOfOperand && SS && !SS->isEmpty() && !HasTrailingLParen) { 951 DeclContext *DC = computeDeclContext(*SS); 952 if (D && isa<CXXRecordDecl>(DC)) { 953 QualType DType; 954 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) { 955 DType = FD->getType().getNonReferenceType(); 956 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 957 DType = Method->getType(); 958 } else if (isa<OverloadedFunctionDecl>(D)) { 959 DType = Context.OverloadTy; 960 } 961 // Could be an inner type. That's diagnosed below, so ignore it here. 962 if (!DType.isNull()) { 963 // The pointer is type- and value-dependent if it points into something 964 // dependent. 965 bool Dependent = false; 966 for (; DC; DC = DC->getParent()) { 967 // FIXME: could stop early at namespace scope. 968 if (DC->isRecord()) { 969 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); 970 if (Context.getTypeDeclType(Record)->isDependentType()) { 971 Dependent = true; 972 break; 973 } 974 } 975 } 976 return Owned(BuildDeclRefExpr(D, DType, Loc, Dependent, Dependent, SS)); 977 } 978 } 979 } 980 981 // We may have found a field within an anonymous union or struct 982 // (C++ [class.union]). 983 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) 984 if (cast<RecordDecl>(FD->getDeclContext())->isAnonymousStructOrUnion()) 985 return BuildAnonymousStructUnionMemberReference(Loc, FD); 986 987 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) { 988 if (!MD->isStatic()) { 989 // C++ [class.mfct.nonstatic]p2: 990 // [...] if name lookup (3.4.1) resolves the name in the 991 // id-expression to a nonstatic nontype member of class X or of 992 // a base class of X, the id-expression is transformed into a 993 // class member access expression (5.2.5) using (*this) (9.3.2) 994 // as the postfix-expression to the left of the '.' operator. 995 DeclContext *Ctx = 0; 996 QualType MemberType; 997 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) { 998 Ctx = FD->getDeclContext(); 999 MemberType = FD->getType(); 1000 1001 if (const ReferenceType *RefType = MemberType->getAsReferenceType()) 1002 MemberType = RefType->getPointeeType(); 1003 else if (!FD->isMutable()) { 1004 unsigned combinedQualifiers 1005 = MemberType.getCVRQualifiers() | MD->getTypeQualifiers(); 1006 MemberType = MemberType.getQualifiedType(combinedQualifiers); 1007 } 1008 } else if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(D)) { 1009 if (!Method->isStatic()) { 1010 Ctx = Method->getParent(); 1011 MemberType = Method->getType(); 1012 } 1013 } else if (OverloadedFunctionDecl *Ovl 1014 = dyn_cast<OverloadedFunctionDecl>(D)) { 1015 for (OverloadedFunctionDecl::function_iterator 1016 Func = Ovl->function_begin(), 1017 FuncEnd = Ovl->function_end(); 1018 Func != FuncEnd; ++Func) { 1019 if (CXXMethodDecl *DMethod = dyn_cast<CXXMethodDecl>(*Func)) 1020 if (!DMethod->isStatic()) { 1021 Ctx = Ovl->getDeclContext(); 1022 MemberType = Context.OverloadTy; 1023 break; 1024 } 1025 } 1026 } 1027 1028 if (Ctx && Ctx->isRecord()) { 1029 QualType CtxType = Context.getTagDeclType(cast<CXXRecordDecl>(Ctx)); 1030 QualType ThisType = Context.getTagDeclType(MD->getParent()); 1031 if ((Context.getCanonicalType(CtxType) 1032 == Context.getCanonicalType(ThisType)) || 1033 IsDerivedFrom(ThisType, CtxType)) { 1034 // Build the implicit member access expression. 1035 Expr *This = new (Context) CXXThisExpr(SourceLocation(), 1036 MD->getThisType(Context)); 1037 return Owned(new (Context) MemberExpr(This, true, D, 1038 Loc, MemberType)); 1039 } 1040 } 1041 } 1042 } 1043 1044 if (FieldDecl *FD = dyn_cast<FieldDecl>(D)) { 1045 if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(CurContext)) { 1046 if (MD->isStatic()) 1047 // "invalid use of member 'x' in static member function" 1048 return ExprError(Diag(Loc,diag::err_invalid_member_use_in_static_method) 1049 << FD->getDeclName()); 1050 } 1051 1052 // Any other ways we could have found the field in a well-formed 1053 // program would have been turned into implicit member expressions 1054 // above. 1055 return ExprError(Diag(Loc, diag::err_invalid_non_static_member_use) 1056 << FD->getDeclName()); 1057 } 1058 1059 if (isa<TypedefDecl>(D)) 1060 return ExprError(Diag(Loc, diag::err_unexpected_typedef) << Name); 1061 if (isa<ObjCInterfaceDecl>(D)) 1062 return ExprError(Diag(Loc, diag::err_unexpected_interface) << Name); 1063 if (isa<NamespaceDecl>(D)) 1064 return ExprError(Diag(Loc, diag::err_unexpected_namespace) << Name); 1065 1066 // Make the DeclRefExpr or BlockDeclRefExpr for the decl. 1067 if (OverloadedFunctionDecl *Ovl = dyn_cast<OverloadedFunctionDecl>(D)) 1068 return Owned(BuildDeclRefExpr(Ovl, Context.OverloadTy, Loc, 1069 false, false, SS)); 1070 else if (TemplateDecl *Template = dyn_cast<TemplateDecl>(D)) 1071 return Owned(BuildDeclRefExpr(Template, Context.OverloadTy, Loc, 1072 false, false, SS)); 1073 ValueDecl *VD = cast<ValueDecl>(D); 1074 1075 // Check whether this declaration can be used. Note that we suppress 1076 // this check when we're going to perform argument-dependent lookup 1077 // on this function name, because this might not be the function 1078 // that overload resolution actually selects. 1079 if (!(ADL && isa<FunctionDecl>(VD)) && DiagnoseUseOfDecl(VD, Loc)) 1080 return ExprError(); 1081 1082 if (VarDecl *Var = dyn_cast<VarDecl>(VD)) { 1083 // Warn about constructs like: 1084 // if (void *X = foo()) { ... } else { X }. 1085 // In the else block, the pointer is always false. 1086 if (Var->isDeclaredInCondition() && Var->getType()->isScalarType()) { 1087 Scope *CheckS = S; 1088 while (CheckS) { 1089 if (CheckS->isWithinElse() && 1090 CheckS->getControlParent()->isDeclScope(DeclPtrTy::make(Var))) { 1091 if (Var->getType()->isBooleanType()) 1092 ExprError(Diag(Loc, diag::warn_value_always_false) 1093 << Var->getDeclName()); 1094 else 1095 ExprError(Diag(Loc, diag::warn_value_always_zero) 1096 << Var->getDeclName()); 1097 break; 1098 } 1099 1100 // Move up one more control parent to check again. 1101 CheckS = CheckS->getControlParent(); 1102 if (CheckS) 1103 CheckS = CheckS->getParent(); 1104 } 1105 } 1106 } else if (FunctionDecl *Func = dyn_cast<FunctionDecl>(VD)) { 1107 if (!getLangOptions().CPlusPlus && !Func->hasPrototype()) { 1108 // C99 DR 316 says that, if a function type comes from a 1109 // function definition (without a prototype), that type is only 1110 // used for checking compatibility. Therefore, when referencing 1111 // the function, we pretend that we don't have the full function 1112 // type. 1113 QualType T = Func->getType(); 1114 QualType NoProtoType = T; 1115 if (const FunctionProtoType *Proto = T->getAsFunctionProtoType()) 1116 NoProtoType = Context.getFunctionNoProtoType(Proto->getResultType()); 1117 return Owned(BuildDeclRefExpr(VD, NoProtoType, Loc, false, false, SS)); 1118 } 1119 } 1120 1121 // Only create DeclRefExpr's for valid Decl's. 1122 if (VD->isInvalidDecl()) 1123 return ExprError(); 1124 1125 // If the identifier reference is inside a block, and it refers to a value 1126 // that is outside the block, create a BlockDeclRefExpr instead of a 1127 // DeclRefExpr. This ensures the value is treated as a copy-in snapshot when 1128 // the block is formed. 1129 // 1130 // We do not do this for things like enum constants, global variables, etc, 1131 // as they do not get snapshotted. 1132 // 1133 if (CurBlock && ShouldSnapshotBlockValueReference(CurBlock, VD)) { 1134 QualType ExprTy = VD->getType().getNonReferenceType(); 1135 // The BlocksAttr indicates the variable is bound by-reference. 1136 if (VD->getAttr<BlocksAttr>()) 1137 return Owned(new (Context) BlockDeclRefExpr(VD, ExprTy, Loc, true)); 1138 1139 // Variable will be bound by-copy, make it const within the closure. 1140 ExprTy.addConst(); 1141 return Owned(new (Context) BlockDeclRefExpr(VD, ExprTy, Loc, false)); 1142 } 1143 // If this reference is not in a block or if the referenced variable is 1144 // within the block, create a normal DeclRefExpr. 1145 1146 bool TypeDependent = false; 1147 bool ValueDependent = false; 1148 if (getLangOptions().CPlusPlus) { 1149 // C++ [temp.dep.expr]p3: 1150 // An id-expression is type-dependent if it contains: 1151 // - an identifier that was declared with a dependent type, 1152 if (VD->getType()->isDependentType()) 1153 TypeDependent = true; 1154 // - FIXME: a template-id that is dependent, 1155 // - a conversion-function-id that specifies a dependent type, 1156 else if (Name.getNameKind() == DeclarationName::CXXConversionFunctionName && 1157 Name.getCXXNameType()->isDependentType()) 1158 TypeDependent = true; 1159 // - a nested-name-specifier that contains a class-name that 1160 // names a dependent type. 1161 else if (SS && !SS->isEmpty()) { 1162 for (DeclContext *DC = computeDeclContext(*SS); 1163 DC; DC = DC->getParent()) { 1164 // FIXME: could stop early at namespace scope. 1165 if (DC->isRecord()) { 1166 CXXRecordDecl *Record = cast<CXXRecordDecl>(DC); 1167 if (Context.getTypeDeclType(Record)->isDependentType()) { 1168 TypeDependent = true; 1169 break; 1170 } 1171 } 1172 } 1173 } 1174 1175 // C++ [temp.dep.constexpr]p2: 1176 // 1177 // An identifier is value-dependent if it is: 1178 // - a name declared with a dependent type, 1179 if (TypeDependent) 1180 ValueDependent = true; 1181 // - the name of a non-type template parameter, 1182 else if (isa<NonTypeTemplateParmDecl>(VD)) 1183 ValueDependent = true; 1184 // - a constant with integral or enumeration type and is 1185 // initialized with an expression that is value-dependent 1186 // (FIXME!). 1187 } 1188 1189 return Owned(BuildDeclRefExpr(VD, VD->getType().getNonReferenceType(), Loc, 1190 TypeDependent, ValueDependent, SS)); 1191} 1192 1193Sema::OwningExprResult Sema::ActOnPredefinedExpr(SourceLocation Loc, 1194 tok::TokenKind Kind) { 1195 PredefinedExpr::IdentType IT; 1196 1197 switch (Kind) { 1198 default: assert(0 && "Unknown simple primary expr!"); 1199 case tok::kw___func__: IT = PredefinedExpr::Func; break; // [C99 6.4.2.2] 1200 case tok::kw___FUNCTION__: IT = PredefinedExpr::Function; break; 1201 case tok::kw___PRETTY_FUNCTION__: IT = PredefinedExpr::PrettyFunction; break; 1202 } 1203 1204 // Pre-defined identifiers are of type char[x], where x is the length of the 1205 // string. 1206 unsigned Length; 1207 if (FunctionDecl *FD = getCurFunctionDecl()) 1208 Length = FD->getIdentifier()->getLength(); 1209 else if (ObjCMethodDecl *MD = getCurMethodDecl()) 1210 Length = MD->getSynthesizedMethodSize(); 1211 else { 1212 Diag(Loc, diag::ext_predef_outside_function); 1213 // __PRETTY_FUNCTION__ -> "top level", the others produce an empty string. 1214 Length = IT == PredefinedExpr::PrettyFunction ? strlen("top level") : 0; 1215 } 1216 1217 1218 llvm::APInt LengthI(32, Length + 1); 1219 QualType ResTy = Context.CharTy.getQualifiedType(QualType::Const); 1220 ResTy = Context.getConstantArrayType(ResTy, LengthI, ArrayType::Normal, 0); 1221 return Owned(new (Context) PredefinedExpr(Loc, ResTy, IT)); 1222} 1223 1224Sema::OwningExprResult Sema::ActOnCharacterConstant(const Token &Tok) { 1225 llvm::SmallString<16> CharBuffer; 1226 CharBuffer.resize(Tok.getLength()); 1227 const char *ThisTokBegin = &CharBuffer[0]; 1228 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin); 1229 1230 CharLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength, 1231 Tok.getLocation(), PP); 1232 if (Literal.hadError()) 1233 return ExprError(); 1234 1235 QualType type = getLangOptions().CPlusPlus ? Context.CharTy : Context.IntTy; 1236 1237 return Owned(new (Context) CharacterLiteral(Literal.getValue(), 1238 Literal.isWide(), 1239 type, Tok.getLocation())); 1240} 1241 1242Action::OwningExprResult Sema::ActOnNumericConstant(const Token &Tok) { 1243 // Fast path for a single digit (which is quite common). A single digit 1244 // cannot have a trigraph, escaped newline, radix prefix, or type suffix. 1245 if (Tok.getLength() == 1) { 1246 const char Val = PP.getSpellingOfSingleCharacterNumericConstant(Tok); 1247 unsigned IntSize = Context.Target.getIntWidth(); 1248 return Owned(new (Context) IntegerLiteral(llvm::APInt(IntSize, Val-'0'), 1249 Context.IntTy, Tok.getLocation())); 1250 } 1251 1252 llvm::SmallString<512> IntegerBuffer; 1253 // Add padding so that NumericLiteralParser can overread by one character. 1254 IntegerBuffer.resize(Tok.getLength()+1); 1255 const char *ThisTokBegin = &IntegerBuffer[0]; 1256 1257 // Get the spelling of the token, which eliminates trigraphs, etc. 1258 unsigned ActualLength = PP.getSpelling(Tok, ThisTokBegin); 1259 1260 NumericLiteralParser Literal(ThisTokBegin, ThisTokBegin+ActualLength, 1261 Tok.getLocation(), PP); 1262 if (Literal.hadError) 1263 return ExprError(); 1264 1265 Expr *Res; 1266 1267 if (Literal.isFloatingLiteral()) { 1268 QualType Ty; 1269 if (Literal.isFloat) 1270 Ty = Context.FloatTy; 1271 else if (!Literal.isLong) 1272 Ty = Context.DoubleTy; 1273 else 1274 Ty = Context.LongDoubleTy; 1275 1276 const llvm::fltSemantics &Format = Context.getFloatTypeSemantics(Ty); 1277 1278 // isExact will be set by GetFloatValue(). 1279 bool isExact = false; 1280 Res = new (Context) FloatingLiteral(Literal.GetFloatValue(Format, &isExact), 1281 &isExact, Ty, Tok.getLocation()); 1282 1283 } else if (!Literal.isIntegerLiteral()) { 1284 return ExprError(); 1285 } else { 1286 QualType Ty; 1287 1288 // long long is a C99 feature. 1289 if (!getLangOptions().C99 && !getLangOptions().CPlusPlus0x && 1290 Literal.isLongLong) 1291 Diag(Tok.getLocation(), diag::ext_longlong); 1292 1293 // Get the value in the widest-possible width. 1294 llvm::APInt ResultVal(Context.Target.getIntMaxTWidth(), 0); 1295 1296 if (Literal.GetIntegerValue(ResultVal)) { 1297 // If this value didn't fit into uintmax_t, warn and force to ull. 1298 Diag(Tok.getLocation(), diag::warn_integer_too_large); 1299 Ty = Context.UnsignedLongLongTy; 1300 assert(Context.getTypeSize(Ty) == ResultVal.getBitWidth() && 1301 "long long is not intmax_t?"); 1302 } else { 1303 // If this value fits into a ULL, try to figure out what else it fits into 1304 // according to the rules of C99 6.4.4.1p5. 1305 1306 // Octal, Hexadecimal, and integers with a U suffix are allowed to 1307 // be an unsigned int. 1308 bool AllowUnsigned = Literal.isUnsigned || Literal.getRadix() != 10; 1309 1310 // Check from smallest to largest, picking the smallest type we can. 1311 unsigned Width = 0; 1312 if (!Literal.isLong && !Literal.isLongLong) { 1313 // Are int/unsigned possibilities? 1314 unsigned IntSize = Context.Target.getIntWidth(); 1315 1316 // Does it fit in a unsigned int? 1317 if (ResultVal.isIntN(IntSize)) { 1318 // Does it fit in a signed int? 1319 if (!Literal.isUnsigned && ResultVal[IntSize-1] == 0) 1320 Ty = Context.IntTy; 1321 else if (AllowUnsigned) 1322 Ty = Context.UnsignedIntTy; 1323 Width = IntSize; 1324 } 1325 } 1326 1327 // Are long/unsigned long possibilities? 1328 if (Ty.isNull() && !Literal.isLongLong) { 1329 unsigned LongSize = Context.Target.getLongWidth(); 1330 1331 // Does it fit in a unsigned long? 1332 if (ResultVal.isIntN(LongSize)) { 1333 // Does it fit in a signed long? 1334 if (!Literal.isUnsigned && ResultVal[LongSize-1] == 0) 1335 Ty = Context.LongTy; 1336 else if (AllowUnsigned) 1337 Ty = Context.UnsignedLongTy; 1338 Width = LongSize; 1339 } 1340 } 1341 1342 // Finally, check long long if needed. 1343 if (Ty.isNull()) { 1344 unsigned LongLongSize = Context.Target.getLongLongWidth(); 1345 1346 // Does it fit in a unsigned long long? 1347 if (ResultVal.isIntN(LongLongSize)) { 1348 // Does it fit in a signed long long? 1349 if (!Literal.isUnsigned && ResultVal[LongLongSize-1] == 0) 1350 Ty = Context.LongLongTy; 1351 else if (AllowUnsigned) 1352 Ty = Context.UnsignedLongLongTy; 1353 Width = LongLongSize; 1354 } 1355 } 1356 1357 // If we still couldn't decide a type, we probably have something that 1358 // does not fit in a signed long long, but has no U suffix. 1359 if (Ty.isNull()) { 1360 Diag(Tok.getLocation(), diag::warn_integer_too_large_for_signed); 1361 Ty = Context.UnsignedLongLongTy; 1362 Width = Context.Target.getLongLongWidth(); 1363 } 1364 1365 if (ResultVal.getBitWidth() != Width) 1366 ResultVal.trunc(Width); 1367 } 1368 Res = new (Context) IntegerLiteral(ResultVal, Ty, Tok.getLocation()); 1369 } 1370 1371 // If this is an imaginary literal, create the ImaginaryLiteral wrapper. 1372 if (Literal.isImaginary) 1373 Res = new (Context) ImaginaryLiteral(Res, 1374 Context.getComplexType(Res->getType())); 1375 1376 return Owned(Res); 1377} 1378 1379Action::OwningExprResult Sema::ActOnParenExpr(SourceLocation L, 1380 SourceLocation R, ExprArg Val) { 1381 Expr *E = Val.takeAs<Expr>(); 1382 assert((E != 0) && "ActOnParenExpr() missing expr"); 1383 return Owned(new (Context) ParenExpr(L, R, E)); 1384} 1385 1386/// The UsualUnaryConversions() function is *not* called by this routine. 1387/// See C99 6.3.2.1p[2-4] for more details. 1388bool Sema::CheckSizeOfAlignOfOperand(QualType exprType, 1389 SourceLocation OpLoc, 1390 const SourceRange &ExprRange, 1391 bool isSizeof) { 1392 if (exprType->isDependentType()) 1393 return false; 1394 1395 // C99 6.5.3.4p1: 1396 if (isa<FunctionType>(exprType)) { 1397 // alignof(function) is allowed as an extension. 1398 if (isSizeof) 1399 Diag(OpLoc, diag::ext_sizeof_function_type) << ExprRange; 1400 return false; 1401 } 1402 1403 // Allow sizeof(void)/alignof(void) as an extension. 1404 if (exprType->isVoidType()) { 1405 Diag(OpLoc, diag::ext_sizeof_void_type) 1406 << (isSizeof ? "sizeof" : "__alignof") << ExprRange; 1407 return false; 1408 } 1409 1410 if (RequireCompleteType(OpLoc, exprType, 1411 isSizeof ? diag::err_sizeof_incomplete_type : 1412 diag::err_alignof_incomplete_type, 1413 ExprRange)) 1414 return true; 1415 1416 // Reject sizeof(interface) and sizeof(interface<proto>) in 64-bit mode. 1417 if (LangOpts.ObjCNonFragileABI && exprType->isObjCInterfaceType()) { 1418 Diag(OpLoc, diag::err_sizeof_nonfragile_interface) 1419 << exprType << isSizeof << ExprRange; 1420 return true; 1421 } 1422 1423 return false; 1424} 1425 1426bool Sema::CheckAlignOfExpr(Expr *E, SourceLocation OpLoc, 1427 const SourceRange &ExprRange) { 1428 E = E->IgnoreParens(); 1429 1430 // alignof decl is always ok. 1431 if (isa<DeclRefExpr>(E)) 1432 return false; 1433 1434 // Cannot know anything else if the expression is dependent. 1435 if (E->isTypeDependent()) 1436 return false; 1437 1438 if (E->getBitField()) { 1439 Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 1 << ExprRange; 1440 return true; 1441 } 1442 1443 // Alignment of a field access is always okay, so long as it isn't a 1444 // bit-field. 1445 if (MemberExpr *ME = dyn_cast<MemberExpr>(E)) 1446 if (dyn_cast<FieldDecl>(ME->getMemberDecl())) 1447 return false; 1448 1449 return CheckSizeOfAlignOfOperand(E->getType(), OpLoc, ExprRange, false); 1450} 1451 1452/// \brief Build a sizeof or alignof expression given a type operand. 1453Action::OwningExprResult 1454Sema::CreateSizeOfAlignOfExpr(QualType T, SourceLocation OpLoc, 1455 bool isSizeOf, SourceRange R) { 1456 if (T.isNull()) 1457 return ExprError(); 1458 1459 if (!T->isDependentType() && 1460 CheckSizeOfAlignOfOperand(T, OpLoc, R, isSizeOf)) 1461 return ExprError(); 1462 1463 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 1464 return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, T, 1465 Context.getSizeType(), OpLoc, 1466 R.getEnd())); 1467} 1468 1469/// \brief Build a sizeof or alignof expression given an expression 1470/// operand. 1471Action::OwningExprResult 1472Sema::CreateSizeOfAlignOfExpr(Expr *E, SourceLocation OpLoc, 1473 bool isSizeOf, SourceRange R) { 1474 // Verify that the operand is valid. 1475 bool isInvalid = false; 1476 if (E->isTypeDependent()) { 1477 // Delay type-checking for type-dependent expressions. 1478 } else if (!isSizeOf) { 1479 isInvalid = CheckAlignOfExpr(E, OpLoc, R); 1480 } else if (E->getBitField()) { // C99 6.5.3.4p1. 1481 Diag(OpLoc, diag::err_sizeof_alignof_bitfield) << 0; 1482 isInvalid = true; 1483 } else { 1484 isInvalid = CheckSizeOfAlignOfOperand(E->getType(), OpLoc, R, true); 1485 } 1486 1487 if (isInvalid) 1488 return ExprError(); 1489 1490 // C99 6.5.3.4p4: the type (an unsigned integer type) is size_t. 1491 return Owned(new (Context) SizeOfAlignOfExpr(isSizeOf, E, 1492 Context.getSizeType(), OpLoc, 1493 R.getEnd())); 1494} 1495 1496/// ActOnSizeOfAlignOfExpr - Handle @c sizeof(type) and @c sizeof @c expr and 1497/// the same for @c alignof and @c __alignof 1498/// Note that the ArgRange is invalid if isType is false. 1499Action::OwningExprResult 1500Sema::ActOnSizeOfAlignOfExpr(SourceLocation OpLoc, bool isSizeof, bool isType, 1501 void *TyOrEx, const SourceRange &ArgRange) { 1502 // If error parsing type, ignore. 1503 if (TyOrEx == 0) return ExprError(); 1504 1505 if (isType) { 1506 QualType ArgTy = QualType::getFromOpaquePtr(TyOrEx); 1507 return CreateSizeOfAlignOfExpr(ArgTy, OpLoc, isSizeof, ArgRange); 1508 } 1509 1510 // Get the end location. 1511 Expr *ArgEx = (Expr *)TyOrEx; 1512 Action::OwningExprResult Result 1513 = CreateSizeOfAlignOfExpr(ArgEx, OpLoc, isSizeof, ArgEx->getSourceRange()); 1514 1515 if (Result.isInvalid()) 1516 DeleteExpr(ArgEx); 1517 1518 return move(Result); 1519} 1520 1521QualType Sema::CheckRealImagOperand(Expr *&V, SourceLocation Loc, bool isReal) { 1522 if (V->isTypeDependent()) 1523 return Context.DependentTy; 1524 1525 // These operators return the element type of a complex type. 1526 if (const ComplexType *CT = V->getType()->getAsComplexType()) 1527 return CT->getElementType(); 1528 1529 // Otherwise they pass through real integer and floating point types here. 1530 if (V->getType()->isArithmeticType()) 1531 return V->getType(); 1532 1533 // Reject anything else. 1534 Diag(Loc, diag::err_realimag_invalid_type) << V->getType() 1535 << (isReal ? "__real" : "__imag"); 1536 return QualType(); 1537} 1538 1539 1540 1541Action::OwningExprResult 1542Sema::ActOnPostfixUnaryOp(Scope *S, SourceLocation OpLoc, 1543 tok::TokenKind Kind, ExprArg Input) { 1544 Expr *Arg = (Expr *)Input.get(); 1545 1546 UnaryOperator::Opcode Opc; 1547 switch (Kind) { 1548 default: assert(0 && "Unknown unary op!"); 1549 case tok::plusplus: Opc = UnaryOperator::PostInc; break; 1550 case tok::minusminus: Opc = UnaryOperator::PostDec; break; 1551 } 1552 1553 if (getLangOptions().CPlusPlus && 1554 (Arg->getType()->isRecordType() || Arg->getType()->isEnumeralType())) { 1555 // Which overloaded operator? 1556 OverloadedOperatorKind OverOp = 1557 (Opc == UnaryOperator::PostInc)? OO_PlusPlus : OO_MinusMinus; 1558 1559 // C++ [over.inc]p1: 1560 // 1561 // [...] If the function is a member function with one 1562 // parameter (which shall be of type int) or a non-member 1563 // function with two parameters (the second of which shall be 1564 // of type int), it defines the postfix increment operator ++ 1565 // for objects of that type. When the postfix increment is 1566 // called as a result of using the ++ operator, the int 1567 // argument will have value zero. 1568 Expr *Args[2] = { 1569 Arg, 1570 new (Context) IntegerLiteral(llvm::APInt(Context.Target.getIntWidth(), 0, 1571 /*isSigned=*/true), Context.IntTy, SourceLocation()) 1572 }; 1573 1574 // Build the candidate set for overloading 1575 OverloadCandidateSet CandidateSet; 1576 AddOperatorCandidates(OverOp, S, OpLoc, Args, 2, CandidateSet); 1577 1578 // Perform overload resolution. 1579 OverloadCandidateSet::iterator Best; 1580 switch (BestViableFunction(CandidateSet, Best)) { 1581 case OR_Success: { 1582 // We found a built-in operator or an overloaded operator. 1583 FunctionDecl *FnDecl = Best->Function; 1584 1585 if (FnDecl) { 1586 // We matched an overloaded operator. Build a call to that 1587 // operator. 1588 1589 // Convert the arguments. 1590 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) { 1591 if (PerformObjectArgumentInitialization(Arg, Method)) 1592 return ExprError(); 1593 } else { 1594 // Convert the arguments. 1595 if (PerformCopyInitialization(Arg, 1596 FnDecl->getParamDecl(0)->getType(), 1597 "passing")) 1598 return ExprError(); 1599 } 1600 1601 // Determine the result type 1602 QualType ResultTy 1603 = FnDecl->getType()->getAsFunctionType()->getResultType(); 1604 ResultTy = ResultTy.getNonReferenceType(); 1605 1606 // Build the actual expression node. 1607 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(), 1608 SourceLocation()); 1609 UsualUnaryConversions(FnExpr); 1610 1611 Input.release(); 1612 Args[0] = Arg; 1613 return Owned(new (Context) CXXOperatorCallExpr(Context, OverOp, FnExpr, 1614 Args, 2, ResultTy, 1615 OpLoc)); 1616 } else { 1617 // We matched a built-in operator. Convert the arguments, then 1618 // break out so that we will build the appropriate built-in 1619 // operator node. 1620 if (PerformCopyInitialization(Arg, Best->BuiltinTypes.ParamTypes[0], 1621 "passing")) 1622 return ExprError(); 1623 1624 break; 1625 } 1626 } 1627 1628 case OR_No_Viable_Function: 1629 // No viable function; fall through to handling this as a 1630 // built-in operator, which will produce an error message for us. 1631 break; 1632 1633 case OR_Ambiguous: 1634 Diag(OpLoc, diag::err_ovl_ambiguous_oper) 1635 << UnaryOperator::getOpcodeStr(Opc) 1636 << Arg->getSourceRange(); 1637 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true); 1638 return ExprError(); 1639 1640 case OR_Deleted: 1641 Diag(OpLoc, diag::err_ovl_deleted_oper) 1642 << Best->Function->isDeleted() 1643 << UnaryOperator::getOpcodeStr(Opc) 1644 << Arg->getSourceRange(); 1645 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true); 1646 return ExprError(); 1647 } 1648 1649 // Either we found no viable overloaded operator or we matched a 1650 // built-in operator. In either case, fall through to trying to 1651 // build a built-in operation. 1652 } 1653 1654 QualType result = CheckIncrementDecrementOperand(Arg, OpLoc, 1655 Opc == UnaryOperator::PostInc); 1656 if (result.isNull()) 1657 return ExprError(); 1658 Input.release(); 1659 return Owned(new (Context) UnaryOperator(Arg, Opc, result, OpLoc)); 1660} 1661 1662Action::OwningExprResult 1663Sema::ActOnArraySubscriptExpr(Scope *S, ExprArg Base, SourceLocation LLoc, 1664 ExprArg Idx, SourceLocation RLoc) { 1665 Expr *LHSExp = static_cast<Expr*>(Base.get()), 1666 *RHSExp = static_cast<Expr*>(Idx.get()); 1667 1668 if (getLangOptions().CPlusPlus && 1669 (LHSExp->isTypeDependent() || RHSExp->isTypeDependent())) { 1670 Base.release(); 1671 Idx.release(); 1672 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 1673 Context.DependentTy, RLoc)); 1674 } 1675 1676 if (getLangOptions().CPlusPlus && 1677 (LHSExp->getType()->isRecordType() || 1678 LHSExp->getType()->isEnumeralType() || 1679 RHSExp->getType()->isRecordType() || 1680 RHSExp->getType()->isEnumeralType())) { 1681 // Add the appropriate overloaded operators (C++ [over.match.oper]) 1682 // to the candidate set. 1683 OverloadCandidateSet CandidateSet; 1684 Expr *Args[2] = { LHSExp, RHSExp }; 1685 AddOperatorCandidates(OO_Subscript, S, LLoc, Args, 2, CandidateSet, 1686 SourceRange(LLoc, RLoc)); 1687 1688 // Perform overload resolution. 1689 OverloadCandidateSet::iterator Best; 1690 switch (BestViableFunction(CandidateSet, Best)) { 1691 case OR_Success: { 1692 // We found a built-in operator or an overloaded operator. 1693 FunctionDecl *FnDecl = Best->Function; 1694 1695 if (FnDecl) { 1696 // We matched an overloaded operator. Build a call to that 1697 // operator. 1698 1699 // Convert the arguments. 1700 if (CXXMethodDecl *Method = dyn_cast<CXXMethodDecl>(FnDecl)) { 1701 if (PerformObjectArgumentInitialization(LHSExp, Method) || 1702 PerformCopyInitialization(RHSExp, 1703 FnDecl->getParamDecl(0)->getType(), 1704 "passing")) 1705 return ExprError(); 1706 } else { 1707 // Convert the arguments. 1708 if (PerformCopyInitialization(LHSExp, 1709 FnDecl->getParamDecl(0)->getType(), 1710 "passing") || 1711 PerformCopyInitialization(RHSExp, 1712 FnDecl->getParamDecl(1)->getType(), 1713 "passing")) 1714 return ExprError(); 1715 } 1716 1717 // Determine the result type 1718 QualType ResultTy 1719 = FnDecl->getType()->getAsFunctionType()->getResultType(); 1720 ResultTy = ResultTy.getNonReferenceType(); 1721 1722 // Build the actual expression node. 1723 Expr *FnExpr = new (Context) DeclRefExpr(FnDecl, FnDecl->getType(), 1724 SourceLocation()); 1725 UsualUnaryConversions(FnExpr); 1726 1727 Base.release(); 1728 Idx.release(); 1729 Args[0] = LHSExp; 1730 Args[1] = RHSExp; 1731 return Owned(new (Context) CXXOperatorCallExpr(Context, OO_Subscript, 1732 FnExpr, Args, 2, 1733 ResultTy, LLoc)); 1734 } else { 1735 // We matched a built-in operator. Convert the arguments, then 1736 // break out so that we will build the appropriate built-in 1737 // operator node. 1738 if (PerformCopyInitialization(LHSExp, Best->BuiltinTypes.ParamTypes[0], 1739 "passing") || 1740 PerformCopyInitialization(RHSExp, Best->BuiltinTypes.ParamTypes[1], 1741 "passing")) 1742 return ExprError(); 1743 1744 break; 1745 } 1746 } 1747 1748 case OR_No_Viable_Function: 1749 // No viable function; fall through to handling this as a 1750 // built-in operator, which will produce an error message for us. 1751 break; 1752 1753 case OR_Ambiguous: 1754 Diag(LLoc, diag::err_ovl_ambiguous_oper) 1755 << "[]" 1756 << LHSExp->getSourceRange() << RHSExp->getSourceRange(); 1757 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true); 1758 return ExprError(); 1759 1760 case OR_Deleted: 1761 Diag(LLoc, diag::err_ovl_deleted_oper) 1762 << Best->Function->isDeleted() 1763 << "[]" 1764 << LHSExp->getSourceRange() << RHSExp->getSourceRange(); 1765 PrintOverloadCandidates(CandidateSet, /*OnlyViable=*/true); 1766 return ExprError(); 1767 } 1768 1769 // Either we found no viable overloaded operator or we matched a 1770 // built-in operator. In either case, fall through to trying to 1771 // build a built-in operation. 1772 } 1773 1774 // Perform default conversions. 1775 DefaultFunctionArrayConversion(LHSExp); 1776 DefaultFunctionArrayConversion(RHSExp); 1777 1778 QualType LHSTy = LHSExp->getType(), RHSTy = RHSExp->getType(); 1779 1780 // C99 6.5.2.1p2: the expression e1[e2] is by definition precisely equivalent 1781 // to the expression *((e1)+(e2)). This means the array "Base" may actually be 1782 // in the subscript position. As a result, we need to derive the array base 1783 // and index from the expression types. 1784 Expr *BaseExpr, *IndexExpr; 1785 QualType ResultType; 1786 if (LHSTy->isDependentType() || RHSTy->isDependentType()) { 1787 BaseExpr = LHSExp; 1788 IndexExpr = RHSExp; 1789 ResultType = Context.DependentTy; 1790 } else if (const PointerType *PTy = LHSTy->getAsPointerType()) { 1791 BaseExpr = LHSExp; 1792 IndexExpr = RHSExp; 1793 ResultType = PTy->getPointeeType(); 1794 } else if (const PointerType *PTy = RHSTy->getAsPointerType()) { 1795 // Handle the uncommon case of "123[Ptr]". 1796 BaseExpr = RHSExp; 1797 IndexExpr = LHSExp; 1798 ResultType = PTy->getPointeeType(); 1799 } else if (const VectorType *VTy = LHSTy->getAsVectorType()) { 1800 BaseExpr = LHSExp; // vectors: V[123] 1801 IndexExpr = RHSExp; 1802 1803 // FIXME: need to deal with const... 1804 ResultType = VTy->getElementType(); 1805 } else if (LHSTy->isArrayType()) { 1806 // If we see an array that wasn't promoted by 1807 // DefaultFunctionArrayConversion, it must be an array that 1808 // wasn't promoted because of the C90 rule that doesn't 1809 // allow promoting non-lvalue arrays. Warn, then 1810 // force the promotion here. 1811 Diag(LHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 1812 LHSExp->getSourceRange(); 1813 ImpCastExprToType(LHSExp, Context.getArrayDecayedType(LHSTy)); 1814 LHSTy = LHSExp->getType(); 1815 1816 BaseExpr = LHSExp; 1817 IndexExpr = RHSExp; 1818 ResultType = LHSTy->getAsPointerType()->getPointeeType(); 1819 } else if (RHSTy->isArrayType()) { 1820 // Same as previous, except for 123[f().a] case 1821 Diag(RHSExp->getLocStart(), diag::ext_subscript_non_lvalue) << 1822 RHSExp->getSourceRange(); 1823 ImpCastExprToType(RHSExp, Context.getArrayDecayedType(RHSTy)); 1824 RHSTy = RHSExp->getType(); 1825 1826 BaseExpr = RHSExp; 1827 IndexExpr = LHSExp; 1828 ResultType = RHSTy->getAsPointerType()->getPointeeType(); 1829 } else { 1830 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_value) 1831 << LHSExp->getSourceRange() << RHSExp->getSourceRange()); 1832 } 1833 // C99 6.5.2.1p1 1834 if (!IndexExpr->getType()->isIntegerType() && !IndexExpr->isTypeDependent()) 1835 return ExprError(Diag(LLoc, diag::err_typecheck_subscript_not_integer) 1836 << IndexExpr->getSourceRange()); 1837 1838 // C99 6.5.2.1p1: "shall have type "pointer to *object* type". Similarly, 1839 // C++ [expr.sub]p1: The type "T" shall be a completely-defined object 1840 // type. Note that Functions are not objects, and that (in C99 parlance) 1841 // incomplete types are not object types. 1842 if (ResultType->isFunctionType()) { 1843 Diag(BaseExpr->getLocStart(), diag::err_subscript_function_type) 1844 << ResultType << BaseExpr->getSourceRange(); 1845 return ExprError(); 1846 } 1847 1848 if (!ResultType->isDependentType() && 1849 RequireCompleteType(LLoc, ResultType, diag::err_subscript_incomplete_type, 1850 BaseExpr->getSourceRange())) 1851 return ExprError(); 1852 1853 // Diagnose bad cases where we step over interface counts. 1854 if (ResultType->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) { 1855 Diag(LLoc, diag::err_subscript_nonfragile_interface) 1856 << ResultType << BaseExpr->getSourceRange(); 1857 return ExprError(); 1858 } 1859 1860 Base.release(); 1861 Idx.release(); 1862 return Owned(new (Context) ArraySubscriptExpr(LHSExp, RHSExp, 1863 ResultType, RLoc)); 1864} 1865 1866QualType Sema:: 1867CheckExtVectorComponent(QualType baseType, SourceLocation OpLoc, 1868 IdentifierInfo &CompName, SourceLocation CompLoc) { 1869 const ExtVectorType *vecType = baseType->getAsExtVectorType(); 1870 1871 // The vector accessor can't exceed the number of elements. 1872 const char *compStr = CompName.getName(); 1873 1874 // This flag determines whether or not the component is one of the four 1875 // special names that indicate a subset of exactly half the elements are 1876 // to be selected. 1877 bool HalvingSwizzle = false; 1878 1879 // This flag determines whether or not CompName has an 's' char prefix, 1880 // indicating that it is a string of hex values to be used as vector indices. 1881 bool HexSwizzle = *compStr == 's'; 1882 1883 // Check that we've found one of the special components, or that the component 1884 // names must come from the same set. 1885 if (!strcmp(compStr, "hi") || !strcmp(compStr, "lo") || 1886 !strcmp(compStr, "even") || !strcmp(compStr, "odd")) { 1887 HalvingSwizzle = true; 1888 } else if (vecType->getPointAccessorIdx(*compStr) != -1) { 1889 do 1890 compStr++; 1891 while (*compStr && vecType->getPointAccessorIdx(*compStr) != -1); 1892 } else if (HexSwizzle || vecType->getNumericAccessorIdx(*compStr) != -1) { 1893 do 1894 compStr++; 1895 while (*compStr && vecType->getNumericAccessorIdx(*compStr) != -1); 1896 } 1897 1898 if (!HalvingSwizzle && *compStr) { 1899 // We didn't get to the end of the string. This means the component names 1900 // didn't come from the same set *or* we encountered an illegal name. 1901 Diag(OpLoc, diag::err_ext_vector_component_name_illegal) 1902 << std::string(compStr,compStr+1) << SourceRange(CompLoc); 1903 return QualType(); 1904 } 1905 1906 // Ensure no component accessor exceeds the width of the vector type it 1907 // operates on. 1908 if (!HalvingSwizzle) { 1909 compStr = CompName.getName(); 1910 1911 if (HexSwizzle) 1912 compStr++; 1913 1914 while (*compStr) { 1915 if (!vecType->isAccessorWithinNumElements(*compStr++)) { 1916 Diag(OpLoc, diag::err_ext_vector_component_exceeds_length) 1917 << baseType << SourceRange(CompLoc); 1918 return QualType(); 1919 } 1920 } 1921 } 1922 1923 // If this is a halving swizzle, verify that the base type has an even 1924 // number of elements. 1925 if (HalvingSwizzle && (vecType->getNumElements() & 1U)) { 1926 Diag(OpLoc, diag::err_ext_vector_component_requires_even) 1927 << baseType << SourceRange(CompLoc); 1928 return QualType(); 1929 } 1930 1931 // The component accessor looks fine - now we need to compute the actual type. 1932 // The vector type is implied by the component accessor. For example, 1933 // vec4.b is a float, vec4.xy is a vec2, vec4.rgb is a vec3, etc. 1934 // vec4.s0 is a float, vec4.s23 is a vec3, etc. 1935 // vec4.hi, vec4.lo, vec4.e, and vec4.o all return vec2. 1936 unsigned CompSize = HalvingSwizzle ? vecType->getNumElements() / 2 1937 : CompName.getLength(); 1938 if (HexSwizzle) 1939 CompSize--; 1940 1941 if (CompSize == 1) 1942 return vecType->getElementType(); 1943 1944 QualType VT = Context.getExtVectorType(vecType->getElementType(), CompSize); 1945 // Now look up the TypeDefDecl from the vector type. Without this, 1946 // diagostics look bad. We want extended vector types to appear built-in. 1947 for (unsigned i = 0, E = ExtVectorDecls.size(); i != E; ++i) { 1948 if (ExtVectorDecls[i]->getUnderlyingType() == VT) 1949 return Context.getTypedefType(ExtVectorDecls[i]); 1950 } 1951 return VT; // should never get here (a typedef type should always be found). 1952} 1953 1954static Decl *FindGetterNameDeclFromProtocolList(const ObjCProtocolDecl*PDecl, 1955 IdentifierInfo &Member, 1956 const Selector &Sel, 1957 ASTContext &Context) { 1958 1959 if (ObjCPropertyDecl *PD = PDecl->FindPropertyDeclaration(Context, &Member)) 1960 return PD; 1961 if (ObjCMethodDecl *OMD = PDecl->getInstanceMethod(Context, Sel)) 1962 return OMD; 1963 1964 for (ObjCProtocolDecl::protocol_iterator I = PDecl->protocol_begin(), 1965 E = PDecl->protocol_end(); I != E; ++I) { 1966 if (Decl *D = FindGetterNameDeclFromProtocolList(*I, Member, Sel, 1967 Context)) 1968 return D; 1969 } 1970 return 0; 1971} 1972 1973static Decl *FindGetterNameDecl(const ObjCQualifiedIdType *QIdTy, 1974 IdentifierInfo &Member, 1975 const Selector &Sel, 1976 ASTContext &Context) { 1977 // Check protocols on qualified interfaces. 1978 Decl *GDecl = 0; 1979 for (ObjCQualifiedIdType::qual_iterator I = QIdTy->qual_begin(), 1980 E = QIdTy->qual_end(); I != E; ++I) { 1981 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Context, &Member)) { 1982 GDecl = PD; 1983 break; 1984 } 1985 // Also must look for a getter name which uses property syntax. 1986 if (ObjCMethodDecl *OMD = (*I)->getInstanceMethod(Context, Sel)) { 1987 GDecl = OMD; 1988 break; 1989 } 1990 } 1991 if (!GDecl) { 1992 for (ObjCQualifiedIdType::qual_iterator I = QIdTy->qual_begin(), 1993 E = QIdTy->qual_end(); I != E; ++I) { 1994 // Search in the protocol-qualifier list of current protocol. 1995 GDecl = FindGetterNameDeclFromProtocolList(*I, Member, Sel, Context); 1996 if (GDecl) 1997 return GDecl; 1998 } 1999 } 2000 return GDecl; 2001} 2002 2003/// FindMethodInNestedImplementations - Look up a method in current and 2004/// all base class implementations. 2005/// 2006ObjCMethodDecl *Sema::FindMethodInNestedImplementations( 2007 const ObjCInterfaceDecl *IFace, 2008 const Selector &Sel) { 2009 ObjCMethodDecl *Method = 0; 2010 if (ObjCImplementationDecl *ImpDecl 2011 = LookupObjCImplementation(IFace->getIdentifier())) 2012 Method = ImpDecl->getInstanceMethod(Context, Sel); 2013 2014 if (!Method && IFace->getSuperClass()) 2015 return FindMethodInNestedImplementations(IFace->getSuperClass(), Sel); 2016 return Method; 2017} 2018 2019Action::OwningExprResult 2020Sema::ActOnMemberReferenceExpr(Scope *S, ExprArg Base, SourceLocation OpLoc, 2021 tok::TokenKind OpKind, SourceLocation MemberLoc, 2022 IdentifierInfo &Member, 2023 DeclPtrTy ObjCImpDecl) { 2024 Expr *BaseExpr = Base.takeAs<Expr>(); 2025 assert(BaseExpr && "no record expression"); 2026 2027 // Perform default conversions. 2028 DefaultFunctionArrayConversion(BaseExpr); 2029 2030 QualType BaseType = BaseExpr->getType(); 2031 assert(!BaseType.isNull() && "no type for member expression"); 2032 2033 // Get the type being accessed in BaseType. If this is an arrow, the BaseExpr 2034 // must have pointer type, and the accessed type is the pointee. 2035 if (OpKind == tok::arrow) { 2036 if (BaseType->isDependentType()) 2037 return Owned(new (Context) CXXUnresolvedMemberExpr(Context, 2038 BaseExpr, true, 2039 OpLoc, 2040 DeclarationName(&Member), 2041 MemberLoc)); 2042 else if (const PointerType *PT = BaseType->getAsPointerType()) 2043 BaseType = PT->getPointeeType(); 2044 else if (getLangOptions().CPlusPlus && BaseType->isRecordType()) 2045 return Owned(BuildOverloadedArrowExpr(S, BaseExpr, OpLoc, 2046 MemberLoc, Member)); 2047 else 2048 return ExprError(Diag(MemberLoc, 2049 diag::err_typecheck_member_reference_arrow) 2050 << BaseType << BaseExpr->getSourceRange()); 2051 } else { 2052 if (BaseType->isDependentType()) { 2053 // Require that the base type isn't a pointer type 2054 // (so we'll report an error for) 2055 // T* t; 2056 // t.f; 2057 // 2058 // In Obj-C++, however, the above expression is valid, since it could be 2059 // accessing the 'f' property if T is an Obj-C interface. The extra check 2060 // allows this, while still reporting an error if T is a struct pointer. 2061 const PointerType *PT = BaseType->getAsPointerType(); 2062 2063 if (!PT || (getLangOptions().ObjC1 && 2064 !PT->getPointeeType()->isRecordType())) 2065 return Owned(new (Context) CXXUnresolvedMemberExpr(Context, 2066 BaseExpr, false, 2067 OpLoc, 2068 DeclarationName(&Member), 2069 MemberLoc)); 2070 } 2071 } 2072 2073 // Handle field access to simple records. This also handles access to fields 2074 // of the ObjC 'id' struct. 2075 if (const RecordType *RTy = BaseType->getAsRecordType()) { 2076 RecordDecl *RDecl = RTy->getDecl(); 2077 if (RequireCompleteType(OpLoc, BaseType, 2078 diag::err_typecheck_incomplete_tag, 2079 BaseExpr->getSourceRange())) 2080 return ExprError(); 2081 2082 // The record definition is complete, now make sure the member is valid. 2083 // FIXME: Qualified name lookup for C++ is a bit more complicated than this. 2084 LookupResult Result 2085 = LookupQualifiedName(RDecl, DeclarationName(&Member), 2086 LookupMemberName, false); 2087 2088 if (!Result) 2089 return ExprError(Diag(MemberLoc, diag::err_typecheck_no_member) 2090 << &Member << BaseExpr->getSourceRange()); 2091 if (Result.isAmbiguous()) { 2092 DiagnoseAmbiguousLookup(Result, DeclarationName(&Member), 2093 MemberLoc, BaseExpr->getSourceRange()); 2094 return ExprError(); 2095 } 2096 2097 NamedDecl *MemberDecl = Result; 2098 2099 // If the decl being referenced had an error, return an error for this 2100 // sub-expr without emitting another error, in order to avoid cascading 2101 // error cases. 2102 if (MemberDecl->isInvalidDecl()) 2103 return ExprError(); 2104 2105 // Check the use of this field 2106 if (DiagnoseUseOfDecl(MemberDecl, MemberLoc)) 2107 return ExprError(); 2108 2109 if (FieldDecl *FD = dyn_cast<FieldDecl>(MemberDecl)) { 2110 // We may have found a field within an anonymous union or struct 2111 // (C++ [class.union]). 2112 if (cast<RecordDecl>(FD->getDeclContext())->isAnonymousStructOrUnion()) 2113 return BuildAnonymousStructUnionMemberReference(MemberLoc, FD, 2114 BaseExpr, OpLoc); 2115 2116 // Figure out the type of the member; see C99 6.5.2.3p3, C++ [expr.ref] 2117 // FIXME: Handle address space modifiers 2118 QualType MemberType = FD->getType(); 2119 if (const ReferenceType *Ref = MemberType->getAsReferenceType()) 2120 MemberType = Ref->getPointeeType(); 2121 else { 2122 unsigned combinedQualifiers = 2123 MemberType.getCVRQualifiers() | BaseType.getCVRQualifiers(); 2124 if (FD->isMutable()) 2125 combinedQualifiers &= ~QualType::Const; 2126 MemberType = MemberType.getQualifiedType(combinedQualifiers); 2127 } 2128 2129 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, FD, 2130 MemberLoc, MemberType)); 2131 } 2132 2133 if (VarDecl *Var = dyn_cast<VarDecl>(MemberDecl)) 2134 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, 2135 Var, MemberLoc, 2136 Var->getType().getNonReferenceType())); 2137 if (FunctionDecl *MemberFn = dyn_cast<FunctionDecl>(MemberDecl)) 2138 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, 2139 MemberFn, MemberLoc, 2140 MemberFn->getType())); 2141 if (OverloadedFunctionDecl *Ovl 2142 = dyn_cast<OverloadedFunctionDecl>(MemberDecl)) 2143 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, Ovl, 2144 MemberLoc, Context.OverloadTy)); 2145 if (EnumConstantDecl *Enum = dyn_cast<EnumConstantDecl>(MemberDecl)) 2146 return Owned(new (Context) MemberExpr(BaseExpr, OpKind == tok::arrow, 2147 Enum, MemberLoc, Enum->getType())); 2148 if (isa<TypeDecl>(MemberDecl)) 2149 return ExprError(Diag(MemberLoc,diag::err_typecheck_member_reference_type) 2150 << DeclarationName(&Member) << int(OpKind == tok::arrow)); 2151 2152 // We found a declaration kind that we didn't expect. This is a 2153 // generic error message that tells the user that she can't refer 2154 // to this member with '.' or '->'. 2155 return ExprError(Diag(MemberLoc, 2156 diag::err_typecheck_member_reference_unknown) 2157 << DeclarationName(&Member) << int(OpKind == tok::arrow)); 2158 } 2159 2160 // Handle access to Objective-C instance variables, such as "Obj->ivar" and 2161 // (*Obj).ivar. 2162 if (const ObjCInterfaceType *IFTy = BaseType->getAsObjCInterfaceType()) { 2163 ObjCInterfaceDecl *ClassDeclared; 2164 if (ObjCIvarDecl *IV = IFTy->getDecl()->lookupInstanceVariable(Context, 2165 &Member, 2166 ClassDeclared)) { 2167 // If the decl being referenced had an error, return an error for this 2168 // sub-expr without emitting another error, in order to avoid cascading 2169 // error cases. 2170 if (IV->isInvalidDecl()) 2171 return ExprError(); 2172 2173 // Check whether we can reference this field. 2174 if (DiagnoseUseOfDecl(IV, MemberLoc)) 2175 return ExprError(); 2176 if (IV->getAccessControl() != ObjCIvarDecl::Public && 2177 IV->getAccessControl() != ObjCIvarDecl::Package) { 2178 ObjCInterfaceDecl *ClassOfMethodDecl = 0; 2179 if (ObjCMethodDecl *MD = getCurMethodDecl()) 2180 ClassOfMethodDecl = MD->getClassInterface(); 2181 else if (ObjCImpDecl && getCurFunctionDecl()) { 2182 // Case of a c-function declared inside an objc implementation. 2183 // FIXME: For a c-style function nested inside an objc implementation 2184 // class, there is no implementation context available, so we pass 2185 // down the context as argument to this routine. Ideally, this context 2186 // need be passed down in the AST node and somehow calculated from the 2187 // AST for a function decl. 2188 Decl *ImplDecl = ObjCImpDecl.getAs<Decl>(); 2189 if (ObjCImplementationDecl *IMPD = 2190 dyn_cast<ObjCImplementationDecl>(ImplDecl)) 2191 ClassOfMethodDecl = IMPD->getClassInterface(); 2192 else if (ObjCCategoryImplDecl* CatImplClass = 2193 dyn_cast<ObjCCategoryImplDecl>(ImplDecl)) 2194 ClassOfMethodDecl = CatImplClass->getClassInterface(); 2195 } 2196 2197 if (IV->getAccessControl() == ObjCIvarDecl::Private) { 2198 if (ClassDeclared != IFTy->getDecl() || 2199 ClassOfMethodDecl != ClassDeclared) 2200 Diag(MemberLoc, diag::error_private_ivar_access) << IV->getDeclName(); 2201 } 2202 // @protected 2203 else if (!IFTy->getDecl()->isSuperClassOf(ClassOfMethodDecl)) 2204 Diag(MemberLoc, diag::error_protected_ivar_access) << IV->getDeclName(); 2205 } 2206 2207 return Owned(new (Context) ObjCIvarRefExpr(IV, IV->getType(), 2208 MemberLoc, BaseExpr, 2209 OpKind == tok::arrow)); 2210 } 2211 return ExprError(Diag(MemberLoc, diag::err_typecheck_member_reference_ivar) 2212 << IFTy->getDecl()->getDeclName() << &Member 2213 << BaseExpr->getSourceRange()); 2214 } 2215 2216 // Handle Objective-C property access, which is "Obj.property" where Obj is a 2217 // pointer to a (potentially qualified) interface type. 2218 const PointerType *PTy; 2219 const ObjCInterfaceType *IFTy; 2220 if (OpKind == tok::period && (PTy = BaseType->getAsPointerType()) && 2221 (IFTy = PTy->getPointeeType()->getAsObjCInterfaceType())) { 2222 ObjCInterfaceDecl *IFace = IFTy->getDecl(); 2223 2224 // Search for a declared property first. 2225 if (ObjCPropertyDecl *PD = IFace->FindPropertyDeclaration(Context, 2226 &Member)) { 2227 // Check whether we can reference this property. 2228 if (DiagnoseUseOfDecl(PD, MemberLoc)) 2229 return ExprError(); 2230 QualType ResTy = PD->getType(); 2231 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member); 2232 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Context, Sel); 2233 if (DiagnosePropertyAccessorMismatch(PD, Getter, MemberLoc)) 2234 ResTy = Getter->getResultType(); 2235 return Owned(new (Context) ObjCPropertyRefExpr(PD, ResTy, 2236 MemberLoc, BaseExpr)); 2237 } 2238 2239 // Check protocols on qualified interfaces. 2240 for (ObjCInterfaceType::qual_iterator I = IFTy->qual_begin(), 2241 E = IFTy->qual_end(); I != E; ++I) 2242 if (ObjCPropertyDecl *PD = (*I)->FindPropertyDeclaration(Context, 2243 &Member)) { 2244 // Check whether we can reference this property. 2245 if (DiagnoseUseOfDecl(PD, MemberLoc)) 2246 return ExprError(); 2247 2248 return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(), 2249 MemberLoc, BaseExpr)); 2250 } 2251 2252 // If that failed, look for an "implicit" property by seeing if the nullary 2253 // selector is implemented. 2254 2255 // FIXME: The logic for looking up nullary and unary selectors should be 2256 // shared with the code in ActOnInstanceMessage. 2257 2258 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member); 2259 ObjCMethodDecl *Getter = IFace->lookupInstanceMethod(Context, Sel); 2260 2261 // If this reference is in an @implementation, check for 'private' methods. 2262 if (!Getter) 2263 Getter = FindMethodInNestedImplementations(IFace, Sel); 2264 2265 // Look through local category implementations associated with the class. 2266 if (!Getter) { 2267 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Getter; i++) { 2268 if (ObjCCategoryImpls[i]->getClassInterface() == IFace) 2269 Getter = ObjCCategoryImpls[i]->getInstanceMethod(Context, Sel); 2270 } 2271 } 2272 if (Getter) { 2273 // Check if we can reference this property. 2274 if (DiagnoseUseOfDecl(Getter, MemberLoc)) 2275 return ExprError(); 2276 } 2277 // If we found a getter then this may be a valid dot-reference, we 2278 // will look for the matching setter, in case it is needed. 2279 Selector SetterSel = 2280 SelectorTable::constructSetterName(PP.getIdentifierTable(), 2281 PP.getSelectorTable(), &Member); 2282 ObjCMethodDecl *Setter = IFace->lookupInstanceMethod(Context, SetterSel); 2283 if (!Setter) { 2284 // If this reference is in an @implementation, also check for 'private' 2285 // methods. 2286 Setter = FindMethodInNestedImplementations(IFace, SetterSel); 2287 } 2288 // Look through local category implementations associated with the class. 2289 if (!Setter) { 2290 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Setter; i++) { 2291 if (ObjCCategoryImpls[i]->getClassInterface() == IFace) 2292 Setter = ObjCCategoryImpls[i]->getInstanceMethod(Context, SetterSel); 2293 } 2294 } 2295 2296 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc)) 2297 return ExprError(); 2298 2299 if (Getter || Setter) { 2300 QualType PType; 2301 2302 if (Getter) 2303 PType = Getter->getResultType(); 2304 else { 2305 for (ObjCMethodDecl::param_iterator PI = Setter->param_begin(), 2306 E = Setter->param_end(); PI != E; ++PI) 2307 PType = (*PI)->getType(); 2308 } 2309 // FIXME: we must check that the setter has property type. 2310 return Owned(new (Context) ObjCKVCRefExpr(Getter, PType, 2311 Setter, MemberLoc, BaseExpr)); 2312 } 2313 return ExprError(Diag(MemberLoc, diag::err_property_not_found) 2314 << &Member << BaseType); 2315 } 2316 // Handle properties on qualified "id" protocols. 2317 const ObjCQualifiedIdType *QIdTy; 2318 if (OpKind == tok::period && (QIdTy = BaseType->getAsObjCQualifiedIdType())) { 2319 // Check protocols on qualified interfaces. 2320 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member); 2321 if (Decl *PMDecl = FindGetterNameDecl(QIdTy, Member, Sel, Context)) { 2322 if (ObjCPropertyDecl *PD = dyn_cast<ObjCPropertyDecl>(PMDecl)) { 2323 // Check the use of this declaration 2324 if (DiagnoseUseOfDecl(PD, MemberLoc)) 2325 return ExprError(); 2326 2327 return Owned(new (Context) ObjCPropertyRefExpr(PD, PD->getType(), 2328 MemberLoc, BaseExpr)); 2329 } 2330 if (ObjCMethodDecl *OMD = dyn_cast<ObjCMethodDecl>(PMDecl)) { 2331 // Check the use of this method. 2332 if (DiagnoseUseOfDecl(OMD, MemberLoc)) 2333 return ExprError(); 2334 2335 return Owned(new (Context) ObjCMessageExpr(BaseExpr, Sel, 2336 OMD->getResultType(), 2337 OMD, OpLoc, MemberLoc, 2338 NULL, 0)); 2339 } 2340 } 2341 2342 return ExprError(Diag(MemberLoc, diag::err_property_not_found) 2343 << &Member << BaseType); 2344 } 2345 // Handle properties on ObjC 'Class' types. 2346 if (OpKind == tok::period && (BaseType == Context.getObjCClassType())) { 2347 // Also must look for a getter name which uses property syntax. 2348 Selector Sel = PP.getSelectorTable().getNullarySelector(&Member); 2349 if (ObjCMethodDecl *MD = getCurMethodDecl()) { 2350 ObjCInterfaceDecl *IFace = MD->getClassInterface(); 2351 ObjCMethodDecl *Getter; 2352 // FIXME: need to also look locally in the implementation. 2353 if ((Getter = IFace->lookupClassMethod(Context, Sel))) { 2354 // Check the use of this method. 2355 if (DiagnoseUseOfDecl(Getter, MemberLoc)) 2356 return ExprError(); 2357 } 2358 // If we found a getter then this may be a valid dot-reference, we 2359 // will look for the matching setter, in case it is needed. 2360 Selector SetterSel = 2361 SelectorTable::constructSetterName(PP.getIdentifierTable(), 2362 PP.getSelectorTable(), &Member); 2363 ObjCMethodDecl *Setter = IFace->lookupClassMethod(Context, SetterSel); 2364 if (!Setter) { 2365 // If this reference is in an @implementation, also check for 'private' 2366 // methods. 2367 Setter = FindMethodInNestedImplementations(IFace, SetterSel); 2368 } 2369 // Look through local category implementations associated with the class. 2370 if (!Setter) { 2371 for (unsigned i = 0; i < ObjCCategoryImpls.size() && !Setter; i++) { 2372 if (ObjCCategoryImpls[i]->getClassInterface() == IFace) 2373 Setter = ObjCCategoryImpls[i]->getClassMethod(Context, SetterSel); 2374 } 2375 } 2376 2377 if (Setter && DiagnoseUseOfDecl(Setter, MemberLoc)) 2378 return ExprError(); 2379 2380 if (Getter || Setter) { 2381 QualType PType; 2382 2383 if (Getter) 2384 PType = Getter->getResultType(); 2385 else { 2386 for (ObjCMethodDecl::param_iterator PI = Setter->param_begin(), 2387 E = Setter->param_end(); PI != E; ++PI) 2388 PType = (*PI)->getType(); 2389 } 2390 // FIXME: we must check that the setter has property type. 2391 return Owned(new (Context) ObjCKVCRefExpr(Getter, PType, 2392 Setter, MemberLoc, BaseExpr)); 2393 } 2394 return ExprError(Diag(MemberLoc, diag::err_property_not_found) 2395 << &Member << BaseType); 2396 } 2397 } 2398 2399 // Handle 'field access' to vectors, such as 'V.xx'. 2400 if (BaseType->isExtVectorType()) { 2401 QualType ret = CheckExtVectorComponent(BaseType, OpLoc, Member, MemberLoc); 2402 if (ret.isNull()) 2403 return ExprError(); 2404 return Owned(new (Context) ExtVectorElementExpr(ret, BaseExpr, Member, 2405 MemberLoc)); 2406 } 2407 2408 Diag(MemberLoc, diag::err_typecheck_member_reference_struct_union) 2409 << BaseType << BaseExpr->getSourceRange(); 2410 2411 // If the user is trying to apply -> or . to a function or function 2412 // pointer, it's probably because they forgot parentheses to call 2413 // the function. Suggest the addition of those parentheses. 2414 if (BaseType == Context.OverloadTy || 2415 BaseType->isFunctionType() || 2416 (BaseType->isPointerType() && 2417 BaseType->getAsPointerType()->isFunctionType())) { 2418 SourceLocation Loc = PP.getLocForEndOfToken(BaseExpr->getLocEnd()); 2419 Diag(Loc, diag::note_member_reference_needs_call) 2420 << CodeModificationHint::CreateInsertion(Loc, "()"); 2421 } 2422 2423 return ExprError(); 2424} 2425 2426/// ConvertArgumentsForCall - Converts the arguments specified in 2427/// Args/NumArgs to the parameter types of the function FDecl with 2428/// function prototype Proto. Call is the call expression itself, and 2429/// Fn is the function expression. For a C++ member function, this 2430/// routine does not attempt to convert the object argument. Returns 2431/// true if the call is ill-formed. 2432bool 2433Sema::ConvertArgumentsForCall(CallExpr *Call, Expr *Fn, 2434 FunctionDecl *FDecl, 2435 const FunctionProtoType *Proto, 2436 Expr **Args, unsigned NumArgs, 2437 SourceLocation RParenLoc) { 2438 // C99 6.5.2.2p7 - the arguments are implicitly converted, as if by 2439 // assignment, to the types of the corresponding parameter, ... 2440 unsigned NumArgsInProto = Proto->getNumArgs(); 2441 unsigned NumArgsToCheck = NumArgs; 2442 bool Invalid = false; 2443 2444 // If too few arguments are available (and we don't have default 2445 // arguments for the remaining parameters), don't make the call. 2446 if (NumArgs < NumArgsInProto) { 2447 if (!FDecl || NumArgs < FDecl->getMinRequiredArguments()) 2448 return Diag(RParenLoc, diag::err_typecheck_call_too_few_args) 2449 << Fn->getType()->isBlockPointerType() << Fn->getSourceRange(); 2450 // Use default arguments for missing arguments 2451 NumArgsToCheck = NumArgsInProto; 2452 Call->setNumArgs(Context, NumArgsInProto); 2453 } 2454 2455 // If too many are passed and not variadic, error on the extras and drop 2456 // them. 2457 if (NumArgs > NumArgsInProto) { 2458 if (!Proto->isVariadic()) { 2459 Diag(Args[NumArgsInProto]->getLocStart(), 2460 diag::err_typecheck_call_too_many_args) 2461 << Fn->getType()->isBlockPointerType() << Fn->getSourceRange() 2462 << SourceRange(Args[NumArgsInProto]->getLocStart(), 2463 Args[NumArgs-1]->getLocEnd()); 2464 // This deletes the extra arguments. 2465 Call->setNumArgs(Context, NumArgsInProto); 2466 Invalid = true; 2467 } 2468 NumArgsToCheck = NumArgsInProto; 2469 } 2470 2471 // Continue to check argument types (even if we have too few/many args). 2472 for (unsigned i = 0; i != NumArgsToCheck; i++) { 2473 QualType ProtoArgType = Proto->getArgType(i); 2474 2475 Expr *Arg; 2476 if (i < NumArgs) { 2477 Arg = Args[i]; 2478 2479 if (RequireCompleteType(Arg->getSourceRange().getBegin(), 2480 ProtoArgType, 2481 diag::err_call_incomplete_argument, 2482 Arg->getSourceRange())) 2483 return true; 2484 2485 // Pass the argument. 2486 if (PerformCopyInitialization(Arg, ProtoArgType, "passing")) 2487 return true; 2488 } else 2489 // We already type-checked the argument, so we know it works. 2490 Arg = new (Context) CXXDefaultArgExpr(FDecl->getParamDecl(i)); 2491 QualType ArgType = Arg->getType(); 2492 2493 Call->setArg(i, Arg); 2494 } 2495 2496 // If this is a variadic call, handle args passed through "...". 2497 if (Proto->isVariadic()) { 2498 VariadicCallType CallType = VariadicFunction; 2499 if (Fn->getType()->isBlockPointerType()) 2500 CallType = VariadicBlock; // Block 2501 else if (isa<MemberExpr>(Fn)) 2502 CallType = VariadicMethod; 2503 2504 // Promote the arguments (C99 6.5.2.2p7). 2505 for (unsigned i = NumArgsInProto; i != NumArgs; i++) { 2506 Expr *Arg = Args[i]; 2507 Invalid |= DefaultVariadicArgumentPromotion(Arg, CallType); 2508 Call->setArg(i, Arg); 2509 } 2510 } 2511 2512 return Invalid; 2513} 2514 2515/// ActOnCallExpr - Handle a call to Fn with the specified array of arguments. 2516/// This provides the location of the left/right parens and a list of comma 2517/// locations. 2518Action::OwningExprResult 2519Sema::ActOnCallExpr(Scope *S, ExprArg fn, SourceLocation LParenLoc, 2520 MultiExprArg args, 2521 SourceLocation *CommaLocs, SourceLocation RParenLoc) { 2522 unsigned NumArgs = args.size(); 2523 Expr *Fn = fn.takeAs<Expr>(); 2524 Expr **Args = reinterpret_cast<Expr**>(args.release()); 2525 assert(Fn && "no function call expression"); 2526 FunctionDecl *FDecl = NULL; 2527 NamedDecl *NDecl = NULL; 2528 DeclarationName UnqualifiedName; 2529 2530 if (getLangOptions().CPlusPlus) { 2531 // Determine whether this is a dependent call inside a C++ template, 2532 // in which case we won't do any semantic analysis now. 2533 // FIXME: Will need to cache the results of name lookup (including ADL) in 2534 // Fn. 2535 bool Dependent = false; 2536 if (Fn->isTypeDependent()) 2537 Dependent = true; 2538 else if (Expr::hasAnyTypeDependentArguments(Args, NumArgs)) 2539 Dependent = true; 2540 2541 if (Dependent) 2542 return Owned(new (Context) CallExpr(Context, Fn, Args, NumArgs, 2543 Context.DependentTy, RParenLoc)); 2544 2545 // Determine whether this is a call to an object (C++ [over.call.object]). 2546 if (Fn->getType()->isRecordType()) 2547 return Owned(BuildCallToObjectOfClassType(S, Fn, LParenLoc, Args, NumArgs, 2548 CommaLocs, RParenLoc)); 2549 2550 // Determine whether this is a call to a member function. 2551 if (MemberExpr *MemExpr = dyn_cast<MemberExpr>(Fn->IgnoreParens())) 2552 if (isa<OverloadedFunctionDecl>(MemExpr->getMemberDecl()) || 2553 isa<CXXMethodDecl>(MemExpr->getMemberDecl())) 2554 return Owned(BuildCallToMemberFunction(S, Fn, LParenLoc, Args, NumArgs, 2555 CommaLocs, RParenLoc)); 2556 } 2557 2558 // If we're directly calling a function, get the appropriate declaration. 2559 DeclRefExpr *DRExpr = NULL; 2560 Expr *FnExpr = Fn; 2561 bool ADL = true; 2562 while (true) { 2563 if (ImplicitCastExpr *IcExpr = dyn_cast<ImplicitCastExpr>(FnExpr)) 2564 FnExpr = IcExpr->getSubExpr(); 2565 else if (ParenExpr *PExpr = dyn_cast<ParenExpr>(FnExpr)) { 2566 // Parentheses around a function disable ADL 2567 // (C++0x [basic.lookup.argdep]p1). 2568 ADL = false; 2569 FnExpr = PExpr->getSubExpr(); 2570 } else if (isa<UnaryOperator>(FnExpr) && 2571 cast<UnaryOperator>(FnExpr)->getOpcode() 2572 == UnaryOperator::AddrOf) { 2573 FnExpr = cast<UnaryOperator>(FnExpr)->getSubExpr(); 2574 } else if ((DRExpr = dyn_cast<DeclRefExpr>(FnExpr))) { 2575 // Qualified names disable ADL (C++0x [basic.lookup.argdep]p1). 2576 ADL &= !isa<QualifiedDeclRefExpr>(DRExpr); 2577 break; 2578 } else if (UnresolvedFunctionNameExpr *DepName 2579 = dyn_cast<UnresolvedFunctionNameExpr>(FnExpr)) { 2580 UnqualifiedName = DepName->getName(); 2581 break; 2582 } else { 2583 // Any kind of name that does not refer to a declaration (or 2584 // set of declarations) disables ADL (C++0x [basic.lookup.argdep]p3). 2585 ADL = false; 2586 break; 2587 } 2588 } 2589 2590 OverloadedFunctionDecl *Ovl = 0; 2591 if (DRExpr) { 2592 FDecl = dyn_cast<FunctionDecl>(DRExpr->getDecl()); 2593 Ovl = dyn_cast<OverloadedFunctionDecl>(DRExpr->getDecl()); 2594 NDecl = dyn_cast<NamedDecl>(DRExpr->getDecl()); 2595 } 2596 2597 if (Ovl || (getLangOptions().CPlusPlus && (FDecl || UnqualifiedName))) { 2598 // We don't perform ADL for implicit declarations of builtins. 2599 if (FDecl && FDecl->getBuiltinID(Context) && FDecl->isImplicit()) 2600 ADL = false; 2601 2602 // We don't perform ADL in C. 2603 if (!getLangOptions().CPlusPlus) 2604 ADL = false; 2605 2606 if (Ovl || ADL) { 2607 FDecl = ResolveOverloadedCallFn(Fn, DRExpr? DRExpr->getDecl() : 0, 2608 UnqualifiedName, LParenLoc, Args, 2609 NumArgs, CommaLocs, RParenLoc, ADL); 2610 if (!FDecl) 2611 return ExprError(); 2612 2613 // Update Fn to refer to the actual function selected. 2614 Expr *NewFn = 0; 2615 if (QualifiedDeclRefExpr *QDRExpr 2616 = dyn_cast_or_null<QualifiedDeclRefExpr>(DRExpr)) 2617 NewFn = new (Context) QualifiedDeclRefExpr(FDecl, FDecl->getType(), 2618 QDRExpr->getLocation(), 2619 false, false, 2620 QDRExpr->getQualifierRange(), 2621 QDRExpr->getQualifier()); 2622 else 2623 NewFn = new (Context) DeclRefExpr(FDecl, FDecl->getType(), 2624 Fn->getSourceRange().getBegin()); 2625 Fn->Destroy(Context); 2626 Fn = NewFn; 2627 } 2628 } 2629 2630 // Promote the function operand. 2631 UsualUnaryConversions(Fn); 2632 2633 // Make the call expr early, before semantic checks. This guarantees cleanup 2634 // of arguments and function on error. 2635 ExprOwningPtr<CallExpr> TheCall(this, new (Context) CallExpr(Context, Fn, 2636 Args, NumArgs, 2637 Context.BoolTy, 2638 RParenLoc)); 2639 2640 const FunctionType *FuncT; 2641 if (!Fn->getType()->isBlockPointerType()) { 2642 // C99 6.5.2.2p1 - "The expression that denotes the called function shall 2643 // have type pointer to function". 2644 const PointerType *PT = Fn->getType()->getAsPointerType(); 2645 if (PT == 0) 2646 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 2647 << Fn->getType() << Fn->getSourceRange()); 2648 FuncT = PT->getPointeeType()->getAsFunctionType(); 2649 } else { // This is a block call. 2650 FuncT = Fn->getType()->getAsBlockPointerType()->getPointeeType()-> 2651 getAsFunctionType(); 2652 } 2653 if (FuncT == 0) 2654 return ExprError(Diag(LParenLoc, diag::err_typecheck_call_not_function) 2655 << Fn->getType() << Fn->getSourceRange()); 2656 2657 // Check for a valid return type 2658 if (!FuncT->getResultType()->isVoidType() && 2659 RequireCompleteType(Fn->getSourceRange().getBegin(), 2660 FuncT->getResultType(), 2661 diag::err_call_incomplete_return, 2662 TheCall->getSourceRange())) 2663 return ExprError(); 2664 2665 // We know the result type of the call, set it. 2666 TheCall->setType(FuncT->getResultType().getNonReferenceType()); 2667 2668 if (const FunctionProtoType *Proto = dyn_cast<FunctionProtoType>(FuncT)) { 2669 if (ConvertArgumentsForCall(&*TheCall, Fn, FDecl, Proto, Args, NumArgs, 2670 RParenLoc)) 2671 return ExprError(); 2672 } else { 2673 assert(isa<FunctionNoProtoType>(FuncT) && "Unknown FunctionType!"); 2674 2675 if (FDecl) { 2676 // Check if we have too few/too many template arguments, based 2677 // on our knowledge of the function definition. 2678 const FunctionDecl *Def = 0; 2679 if (FDecl->getBody(Context, Def) && NumArgs != Def->param_size()) 2680 Diag(RParenLoc, diag::warn_call_wrong_number_of_arguments) 2681 << (NumArgs > Def->param_size()) << FDecl << Fn->getSourceRange(); 2682 } 2683 2684 // Promote the arguments (C99 6.5.2.2p6). 2685 for (unsigned i = 0; i != NumArgs; i++) { 2686 Expr *Arg = Args[i]; 2687 DefaultArgumentPromotion(Arg); 2688 if (RequireCompleteType(Arg->getSourceRange().getBegin(), 2689 Arg->getType(), 2690 diag::err_call_incomplete_argument, 2691 Arg->getSourceRange())) 2692 return ExprError(); 2693 TheCall->setArg(i, Arg); 2694 } 2695 } 2696 2697 if (CXXMethodDecl *Method = dyn_cast_or_null<CXXMethodDecl>(FDecl)) 2698 if (!Method->isStatic()) 2699 return ExprError(Diag(LParenLoc, diag::err_member_call_without_object) 2700 << Fn->getSourceRange()); 2701 2702 // Check for sentinels 2703 if (NDecl) 2704 DiagnoseSentinelCalls(NDecl, LParenLoc, Args, NumArgs); 2705 // Do special checking on direct calls to functions. 2706 if (FDecl) 2707 return CheckFunctionCall(FDecl, TheCall.take()); 2708 if (NDecl) 2709 return CheckBlockCall(NDecl, TheCall.take()); 2710 2711 return Owned(TheCall.take()); 2712} 2713 2714Action::OwningExprResult 2715Sema::ActOnCompoundLiteral(SourceLocation LParenLoc, TypeTy *Ty, 2716 SourceLocation RParenLoc, ExprArg InitExpr) { 2717 assert((Ty != 0) && "ActOnCompoundLiteral(): missing type"); 2718 QualType literalType = QualType::getFromOpaquePtr(Ty); 2719 // FIXME: put back this assert when initializers are worked out. 2720 //assert((InitExpr != 0) && "ActOnCompoundLiteral(): missing expression"); 2721 Expr *literalExpr = static_cast<Expr*>(InitExpr.get()); 2722 2723 if (literalType->isArrayType()) { 2724 if (literalType->isVariableArrayType()) 2725 return ExprError(Diag(LParenLoc, diag::err_variable_object_no_init) 2726 << SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd())); 2727 } else if (!literalType->isDependentType() && 2728 RequireCompleteType(LParenLoc, literalType, 2729 diag::err_typecheck_decl_incomplete_type, 2730 SourceRange(LParenLoc, literalExpr->getSourceRange().getEnd()))) 2731 return ExprError(); 2732 2733 if (CheckInitializerTypes(literalExpr, literalType, LParenLoc, 2734 DeclarationName(), /*FIXME:DirectInit=*/false)) 2735 return ExprError(); 2736 2737 bool isFileScope = getCurFunctionOrMethodDecl() == 0; 2738 if (isFileScope) { // 6.5.2.5p3 2739 if (CheckForConstantInitializer(literalExpr, literalType)) 2740 return ExprError(); 2741 } 2742 InitExpr.release(); 2743 return Owned(new (Context) CompoundLiteralExpr(LParenLoc, literalType, 2744 literalExpr, isFileScope)); 2745} 2746 2747Action::OwningExprResult 2748Sema::ActOnInitList(SourceLocation LBraceLoc, MultiExprArg initlist, 2749 SourceLocation RBraceLoc) { 2750 unsigned NumInit = initlist.size(); 2751 Expr **InitList = reinterpret_cast<Expr**>(initlist.release()); 2752 2753 // Semantic analysis for initializers is done by ActOnDeclarator() and 2754 // CheckInitializer() - it requires knowledge of the object being intialized. 2755 2756 InitListExpr *E = new (Context) InitListExpr(LBraceLoc, InitList, NumInit, 2757 RBraceLoc); 2758 E->setType(Context.VoidTy); // FIXME: just a place holder for now. 2759 return Owned(E); 2760} 2761 2762/// CheckCastTypes - Check type constraints for casting between types. 2763bool Sema::CheckCastTypes(SourceRange TyR, QualType castType, Expr *&castExpr) { 2764 UsualUnaryConversions(castExpr); 2765 2766 // C99 6.5.4p2: the cast type needs to be void or scalar and the expression 2767 // type needs to be scalar. 2768 if (castType->isVoidType()) { 2769 // Cast to void allows any expr type. 2770 } else if (castType->isDependentType() || castExpr->isTypeDependent()) { 2771 // We can't check any more until template instantiation time. 2772 } else if (!castType->isScalarType() && !castType->isVectorType()) { 2773 if (Context.getCanonicalType(castType).getUnqualifiedType() == 2774 Context.getCanonicalType(castExpr->getType().getUnqualifiedType()) && 2775 (castType->isStructureType() || castType->isUnionType())) { 2776 // GCC struct/union extension: allow cast to self. 2777 // FIXME: Check that the cast destination type is complete. 2778 Diag(TyR.getBegin(), diag::ext_typecheck_cast_nonscalar) 2779 << castType << castExpr->getSourceRange(); 2780 } else if (castType->isUnionType()) { 2781 // GCC cast to union extension 2782 RecordDecl *RD = castType->getAsRecordType()->getDecl(); 2783 RecordDecl::field_iterator Field, FieldEnd; 2784 for (Field = RD->field_begin(Context), FieldEnd = RD->field_end(Context); 2785 Field != FieldEnd; ++Field) { 2786 if (Context.getCanonicalType(Field->getType()).getUnqualifiedType() == 2787 Context.getCanonicalType(castExpr->getType()).getUnqualifiedType()) { 2788 Diag(TyR.getBegin(), diag::ext_typecheck_cast_to_union) 2789 << castExpr->getSourceRange(); 2790 break; 2791 } 2792 } 2793 if (Field == FieldEnd) 2794 return Diag(TyR.getBegin(), diag::err_typecheck_cast_to_union_no_type) 2795 << castExpr->getType() << castExpr->getSourceRange(); 2796 } else { 2797 // Reject any other conversions to non-scalar types. 2798 return Diag(TyR.getBegin(), diag::err_typecheck_cond_expect_scalar) 2799 << castType << castExpr->getSourceRange(); 2800 } 2801 } else if (!castExpr->getType()->isScalarType() && 2802 !castExpr->getType()->isVectorType()) { 2803 return Diag(castExpr->getLocStart(), 2804 diag::err_typecheck_expect_scalar_operand) 2805 << castExpr->getType() << castExpr->getSourceRange(); 2806 } else if (castExpr->getType()->isVectorType()) { 2807 if (CheckVectorCast(TyR, castExpr->getType(), castType)) 2808 return true; 2809 } else if (castType->isVectorType()) { 2810 if (CheckVectorCast(TyR, castType, castExpr->getType())) 2811 return true; 2812 } else if (getLangOptions().ObjC1 && isa<ObjCSuperExpr>(castExpr)) { 2813 return Diag(castExpr->getLocStart(), diag::err_illegal_super_cast) << TyR; 2814 } else if (!castType->isArithmeticType()) { 2815 QualType castExprType = castExpr->getType(); 2816 if (!castExprType->isIntegralType() && castExprType->isArithmeticType()) 2817 return Diag(castExpr->getLocStart(), 2818 diag::err_cast_pointer_from_non_pointer_int) 2819 << castExprType << castExpr->getSourceRange(); 2820 } else if (!castExpr->getType()->isArithmeticType()) { 2821 if (!castType->isIntegralType() && castType->isArithmeticType()) 2822 return Diag(castExpr->getLocStart(), 2823 diag::err_cast_pointer_to_non_pointer_int) 2824 << castType << castExpr->getSourceRange(); 2825 } 2826 if (isa<ObjCSelectorExpr>(castExpr)) 2827 return Diag(castExpr->getLocStart(), diag::err_cast_selector_expr); 2828 return false; 2829} 2830 2831bool Sema::CheckVectorCast(SourceRange R, QualType VectorTy, QualType Ty) { 2832 assert(VectorTy->isVectorType() && "Not a vector type!"); 2833 2834 if (Ty->isVectorType() || Ty->isIntegerType()) { 2835 if (Context.getTypeSize(VectorTy) != Context.getTypeSize(Ty)) 2836 return Diag(R.getBegin(), 2837 Ty->isVectorType() ? 2838 diag::err_invalid_conversion_between_vectors : 2839 diag::err_invalid_conversion_between_vector_and_integer) 2840 << VectorTy << Ty << R; 2841 } else 2842 return Diag(R.getBegin(), 2843 diag::err_invalid_conversion_between_vector_and_scalar) 2844 << VectorTy << Ty << R; 2845 2846 return false; 2847} 2848 2849Action::OwningExprResult 2850Sema::ActOnCastExpr(SourceLocation LParenLoc, TypeTy *Ty, 2851 SourceLocation RParenLoc, ExprArg Op) { 2852 assert((Ty != 0) && (Op.get() != 0) && 2853 "ActOnCastExpr(): missing type or expr"); 2854 2855 Expr *castExpr = Op.takeAs<Expr>(); 2856 QualType castType = QualType::getFromOpaquePtr(Ty); 2857 2858 if (CheckCastTypes(SourceRange(LParenLoc, RParenLoc), castType, castExpr)) 2859 return ExprError(); 2860 return Owned(new (Context) CStyleCastExpr(castType, castExpr, castType, 2861 LParenLoc, RParenLoc)); 2862} 2863 2864/// Note that lhs is not null here, even if this is the gnu "x ?: y" extension. 2865/// In that case, lhs = cond. 2866/// C99 6.5.15 2867QualType Sema::CheckConditionalOperands(Expr *&Cond, Expr *&LHS, Expr *&RHS, 2868 SourceLocation QuestionLoc) { 2869 // C++ is sufficiently different to merit its own checker. 2870 if (getLangOptions().CPlusPlus) 2871 return CXXCheckConditionalOperands(Cond, LHS, RHS, QuestionLoc); 2872 2873 UsualUnaryConversions(Cond); 2874 UsualUnaryConversions(LHS); 2875 UsualUnaryConversions(RHS); 2876 QualType CondTy = Cond->getType(); 2877 QualType LHSTy = LHS->getType(); 2878 QualType RHSTy = RHS->getType(); 2879 2880 // first, check the condition. 2881 if (!CondTy->isScalarType()) { // C99 6.5.15p2 2882 Diag(Cond->getLocStart(), diag::err_typecheck_cond_expect_scalar) 2883 << CondTy; 2884 return QualType(); 2885 } 2886 2887 // Now check the two expressions. 2888 2889 // If both operands have arithmetic type, do the usual arithmetic conversions 2890 // to find a common type: C99 6.5.15p3,5. 2891 if (LHSTy->isArithmeticType() && RHSTy->isArithmeticType()) { 2892 UsualArithmeticConversions(LHS, RHS); 2893 return LHS->getType(); 2894 } 2895 2896 // If both operands are the same structure or union type, the result is that 2897 // type. 2898 if (const RecordType *LHSRT = LHSTy->getAsRecordType()) { // C99 6.5.15p3 2899 if (const RecordType *RHSRT = RHSTy->getAsRecordType()) 2900 if (LHSRT->getDecl() == RHSRT->getDecl()) 2901 // "If both the operands have structure or union type, the result has 2902 // that type." This implies that CV qualifiers are dropped. 2903 return LHSTy.getUnqualifiedType(); 2904 // FIXME: Type of conditional expression must be complete in C mode. 2905 } 2906 2907 // C99 6.5.15p5: "If both operands have void type, the result has void type." 2908 // The following || allows only one side to be void (a GCC-ism). 2909 if (LHSTy->isVoidType() || RHSTy->isVoidType()) { 2910 if (!LHSTy->isVoidType()) 2911 Diag(RHS->getLocStart(), diag::ext_typecheck_cond_one_void) 2912 << RHS->getSourceRange(); 2913 if (!RHSTy->isVoidType()) 2914 Diag(LHS->getLocStart(), diag::ext_typecheck_cond_one_void) 2915 << LHS->getSourceRange(); 2916 ImpCastExprToType(LHS, Context.VoidTy); 2917 ImpCastExprToType(RHS, Context.VoidTy); 2918 return Context.VoidTy; 2919 } 2920 // C99 6.5.15p6 - "if one operand is a null pointer constant, the result has 2921 // the type of the other operand." 2922 if ((LHSTy->isPointerType() || LHSTy->isBlockPointerType() || 2923 Context.isObjCObjectPointerType(LHSTy)) && 2924 RHS->isNullPointerConstant(Context)) { 2925 ImpCastExprToType(RHS, LHSTy); // promote the null to a pointer. 2926 return LHSTy; 2927 } 2928 if ((RHSTy->isPointerType() || RHSTy->isBlockPointerType() || 2929 Context.isObjCObjectPointerType(RHSTy)) && 2930 LHS->isNullPointerConstant(Context)) { 2931 ImpCastExprToType(LHS, RHSTy); // promote the null to a pointer. 2932 return RHSTy; 2933 } 2934 2935 const PointerType *LHSPT = LHSTy->getAsPointerType(); 2936 const PointerType *RHSPT = RHSTy->getAsPointerType(); 2937 const BlockPointerType *LHSBPT = LHSTy->getAsBlockPointerType(); 2938 const BlockPointerType *RHSBPT = RHSTy->getAsBlockPointerType(); 2939 2940 // Handle the case where both operands are pointers before we handle null 2941 // pointer constants in case both operands are null pointer constants. 2942 if ((LHSPT || LHSBPT) && (RHSPT || RHSBPT)) { // C99 6.5.15p3,6 2943 // get the "pointed to" types 2944 QualType lhptee = (LHSPT ? LHSPT->getPointeeType() 2945 : LHSBPT->getPointeeType()); 2946 QualType rhptee = (RHSPT ? RHSPT->getPointeeType() 2947 : RHSBPT->getPointeeType()); 2948 2949 // ignore qualifiers on void (C99 6.5.15p3, clause 6) 2950 if (lhptee->isVoidType() 2951 && (RHSBPT || rhptee->isIncompleteOrObjectType())) { 2952 // Figure out necessary qualifiers (C99 6.5.15p6) 2953 QualType destPointee=lhptee.getQualifiedType(rhptee.getCVRQualifiers()); 2954 QualType destType = Context.getPointerType(destPointee); 2955 ImpCastExprToType(LHS, destType); // add qualifiers if necessary 2956 ImpCastExprToType(RHS, destType); // promote to void* 2957 return destType; 2958 } 2959 if (rhptee->isVoidType() 2960 && (LHSBPT || lhptee->isIncompleteOrObjectType())) { 2961 QualType destPointee=rhptee.getQualifiedType(lhptee.getCVRQualifiers()); 2962 QualType destType = Context.getPointerType(destPointee); 2963 ImpCastExprToType(LHS, destType); // add qualifiers if necessary 2964 ImpCastExprToType(RHS, destType); // promote to void* 2965 return destType; 2966 } 2967 2968 bool sameKind = (LHSPT && RHSPT) || (LHSBPT && RHSBPT); 2969 if (sameKind 2970 && Context.getCanonicalType(LHSTy) == Context.getCanonicalType(RHSTy)) { 2971 // Two identical pointer types are always compatible. 2972 return LHSTy; 2973 } 2974 2975 QualType compositeType = LHSTy; 2976 2977 // If either type is an Objective-C object type then check 2978 // compatibility according to Objective-C. 2979 if (Context.isObjCObjectPointerType(LHSTy) || 2980 Context.isObjCObjectPointerType(RHSTy)) { 2981 // If both operands are interfaces and either operand can be 2982 // assigned to the other, use that type as the composite 2983 // type. This allows 2984 // xxx ? (A*) a : (B*) b 2985 // where B is a subclass of A. 2986 // 2987 // Additionally, as for assignment, if either type is 'id' 2988 // allow silent coercion. Finally, if the types are 2989 // incompatible then make sure to use 'id' as the composite 2990 // type so the result is acceptable for sending messages to. 2991 2992 // FIXME: Consider unifying with 'areComparableObjCPointerTypes'. 2993 // It could return the composite type. 2994 const ObjCInterfaceType* LHSIface = lhptee->getAsObjCInterfaceType(); 2995 const ObjCInterfaceType* RHSIface = rhptee->getAsObjCInterfaceType(); 2996 if (LHSIface && RHSIface && 2997 Context.canAssignObjCInterfaces(LHSIface, RHSIface)) { 2998 compositeType = LHSTy; 2999 } else if (LHSIface && RHSIface && 3000 Context.canAssignObjCInterfaces(RHSIface, LHSIface)) { 3001 compositeType = RHSTy; 3002 } else if (Context.isObjCIdStructType(lhptee) || 3003 Context.isObjCIdStructType(rhptee)) { 3004 compositeType = Context.getObjCIdType(); 3005 } else if (LHSBPT || RHSBPT) { 3006 if (!sameKind 3007 || !Context.typesAreBlockCompatible(lhptee.getUnqualifiedType(), 3008 rhptee.getUnqualifiedType())) 3009 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 3010 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange(); 3011 return QualType(); 3012 } else { 3013 Diag(QuestionLoc, diag::ext_typecheck_cond_incompatible_operands) 3014 << LHSTy << RHSTy 3015 << LHS->getSourceRange() << RHS->getSourceRange(); 3016 QualType incompatTy = Context.getObjCIdType(); 3017 ImpCastExprToType(LHS, incompatTy); 3018 ImpCastExprToType(RHS, incompatTy); 3019 return incompatTy; 3020 } 3021 } else if (!sameKind 3022 || !Context.typesAreCompatible(lhptee.getUnqualifiedType(), 3023 rhptee.getUnqualifiedType())) { 3024 Diag(QuestionLoc, diag::warn_typecheck_cond_incompatible_pointers) 3025 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange(); 3026 // In this situation, we assume void* type. No especially good 3027 // reason, but this is what gcc does, and we do have to pick 3028 // to get a consistent AST. 3029 QualType incompatTy = Context.getPointerType(Context.VoidTy); 3030 ImpCastExprToType(LHS, incompatTy); 3031 ImpCastExprToType(RHS, incompatTy); 3032 return incompatTy; 3033 } 3034 // The pointer types are compatible. 3035 // C99 6.5.15p6: If both operands are pointers to compatible types *or* to 3036 // differently qualified versions of compatible types, the result type is 3037 // a pointer to an appropriately qualified version of the *composite* 3038 // type. 3039 // FIXME: Need to calculate the composite type. 3040 // FIXME: Need to add qualifiers 3041 ImpCastExprToType(LHS, compositeType); 3042 ImpCastExprToType(RHS, compositeType); 3043 return compositeType; 3044 } 3045 3046 // GCC compatibility: soften pointer/integer mismatch. 3047 if (RHSTy->isPointerType() && LHSTy->isIntegerType()) { 3048 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch) 3049 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange(); 3050 ImpCastExprToType(LHS, RHSTy); // promote the integer to a pointer. 3051 return RHSTy; 3052 } 3053 if (LHSTy->isPointerType() && RHSTy->isIntegerType()) { 3054 Diag(QuestionLoc, diag::warn_typecheck_cond_pointer_integer_mismatch) 3055 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange(); 3056 ImpCastExprToType(RHS, LHSTy); // promote the integer to a pointer. 3057 return LHSTy; 3058 } 3059 3060 // Need to handle "id<xx>" explicitly. Unlike "id", whose canonical type 3061 // evaluates to "struct objc_object *" (and is handled above when comparing 3062 // id with statically typed objects). 3063 if (LHSTy->isObjCQualifiedIdType() || RHSTy->isObjCQualifiedIdType()) { 3064 // GCC allows qualified id and any Objective-C type to devolve to 3065 // id. Currently localizing to here until clear this should be 3066 // part of ObjCQualifiedIdTypesAreCompatible. 3067 if (ObjCQualifiedIdTypesAreCompatible(LHSTy, RHSTy, true) || 3068 (LHSTy->isObjCQualifiedIdType() && 3069 Context.isObjCObjectPointerType(RHSTy)) || 3070 (RHSTy->isObjCQualifiedIdType() && 3071 Context.isObjCObjectPointerType(LHSTy))) { 3072 // FIXME: This is not the correct composite type. This only happens to 3073 // work because id can more or less be used anywhere, however this may 3074 // change the type of method sends. 3075 3076 // FIXME: gcc adds some type-checking of the arguments and emits 3077 // (confusing) incompatible comparison warnings in some 3078 // cases. Investigate. 3079 QualType compositeType = Context.getObjCIdType(); 3080 ImpCastExprToType(LHS, compositeType); 3081 ImpCastExprToType(RHS, compositeType); 3082 return compositeType; 3083 } 3084 } 3085 3086 // Otherwise, the operands are not compatible. 3087 Diag(QuestionLoc, diag::err_typecheck_cond_incompatible_operands) 3088 << LHSTy << RHSTy << LHS->getSourceRange() << RHS->getSourceRange(); 3089 return QualType(); 3090} 3091 3092/// ActOnConditionalOp - Parse a ?: operation. Note that 'LHS' may be null 3093/// in the case of a the GNU conditional expr extension. 3094Action::OwningExprResult Sema::ActOnConditionalOp(SourceLocation QuestionLoc, 3095 SourceLocation ColonLoc, 3096 ExprArg Cond, ExprArg LHS, 3097 ExprArg RHS) { 3098 Expr *CondExpr = (Expr *) Cond.get(); 3099 Expr *LHSExpr = (Expr *) LHS.get(), *RHSExpr = (Expr *) RHS.get(); 3100 3101 // If this is the gnu "x ?: y" extension, analyze the types as though the LHS 3102 // was the condition. 3103 bool isLHSNull = LHSExpr == 0; 3104 if (isLHSNull) 3105 LHSExpr = CondExpr; 3106 3107 QualType result = CheckConditionalOperands(CondExpr, LHSExpr, 3108 RHSExpr, QuestionLoc); 3109 if (result.isNull()) 3110 return ExprError(); 3111 3112 Cond.release(); 3113 LHS.release(); 3114 RHS.release(); 3115 return Owned(new (Context) ConditionalOperator(CondExpr, 3116 isLHSNull ? 0 : LHSExpr, 3117 RHSExpr, result)); 3118} 3119 3120 3121// CheckPointerTypesForAssignment - This is a very tricky routine (despite 3122// being closely modeled after the C99 spec:-). The odd characteristic of this 3123// routine is it effectively iqnores the qualifiers on the top level pointee. 3124// This circumvents the usual type rules specified in 6.2.7p1 & 6.7.5.[1-3]. 3125// FIXME: add a couple examples in this comment. 3126Sema::AssignConvertType 3127Sema::CheckPointerTypesForAssignment(QualType lhsType, QualType rhsType) { 3128 QualType lhptee, rhptee; 3129 3130 // get the "pointed to" type (ignoring qualifiers at the top level) 3131 lhptee = lhsType->getAsPointerType()->getPointeeType(); 3132 rhptee = rhsType->getAsPointerType()->getPointeeType(); 3133 3134 // make sure we operate on the canonical type 3135 lhptee = Context.getCanonicalType(lhptee); 3136 rhptee = Context.getCanonicalType(rhptee); 3137 3138 AssignConvertType ConvTy = Compatible; 3139 3140 // C99 6.5.16.1p1: This following citation is common to constraints 3141 // 3 & 4 (below). ...and the type *pointed to* by the left has all the 3142 // qualifiers of the type *pointed to* by the right; 3143 // FIXME: Handle ExtQualType 3144 if (!lhptee.isAtLeastAsQualifiedAs(rhptee)) 3145 ConvTy = CompatiblePointerDiscardsQualifiers; 3146 3147 // C99 6.5.16.1p1 (constraint 4): If one operand is a pointer to an object or 3148 // incomplete type and the other is a pointer to a qualified or unqualified 3149 // version of void... 3150 if (lhptee->isVoidType()) { 3151 if (rhptee->isIncompleteOrObjectType()) 3152 return ConvTy; 3153 3154 // As an extension, we allow cast to/from void* to function pointer. 3155 assert(rhptee->isFunctionType()); 3156 return FunctionVoidPointer; 3157 } 3158 3159 if (rhptee->isVoidType()) { 3160 if (lhptee->isIncompleteOrObjectType()) 3161 return ConvTy; 3162 3163 // As an extension, we allow cast to/from void* to function pointer. 3164 assert(lhptee->isFunctionType()); 3165 return FunctionVoidPointer; 3166 } 3167 // C99 6.5.16.1p1 (constraint 3): both operands are pointers to qualified or 3168 // unqualified versions of compatible types, ... 3169 lhptee = lhptee.getUnqualifiedType(); 3170 rhptee = rhptee.getUnqualifiedType(); 3171 if (!Context.typesAreCompatible(lhptee, rhptee)) { 3172 // Check if the pointee types are compatible ignoring the sign. 3173 // We explicitly check for char so that we catch "char" vs 3174 // "unsigned char" on systems where "char" is unsigned. 3175 if (lhptee->isCharType()) { 3176 lhptee = Context.UnsignedCharTy; 3177 } else if (lhptee->isSignedIntegerType()) { 3178 lhptee = Context.getCorrespondingUnsignedType(lhptee); 3179 } 3180 if (rhptee->isCharType()) { 3181 rhptee = Context.UnsignedCharTy; 3182 } else if (rhptee->isSignedIntegerType()) { 3183 rhptee = Context.getCorrespondingUnsignedType(rhptee); 3184 } 3185 if (lhptee == rhptee) { 3186 // Types are compatible ignoring the sign. Qualifier incompatibility 3187 // takes priority over sign incompatibility because the sign 3188 // warning can be disabled. 3189 if (ConvTy != Compatible) 3190 return ConvTy; 3191 return IncompatiblePointerSign; 3192 } 3193 // General pointer incompatibility takes priority over qualifiers. 3194 return IncompatiblePointer; 3195 } 3196 return ConvTy; 3197} 3198 3199/// CheckBlockPointerTypesForAssignment - This routine determines whether two 3200/// block pointer types are compatible or whether a block and normal pointer 3201/// are compatible. It is more restrict than comparing two function pointer 3202// types. 3203Sema::AssignConvertType 3204Sema::CheckBlockPointerTypesForAssignment(QualType lhsType, 3205 QualType rhsType) { 3206 QualType lhptee, rhptee; 3207 3208 // get the "pointed to" type (ignoring qualifiers at the top level) 3209 lhptee = lhsType->getAsBlockPointerType()->getPointeeType(); 3210 rhptee = rhsType->getAsBlockPointerType()->getPointeeType(); 3211 3212 // make sure we operate on the canonical type 3213 lhptee = Context.getCanonicalType(lhptee); 3214 rhptee = Context.getCanonicalType(rhptee); 3215 3216 AssignConvertType ConvTy = Compatible; 3217 3218 // For blocks we enforce that qualifiers are identical. 3219 if (lhptee.getCVRQualifiers() != rhptee.getCVRQualifiers()) 3220 ConvTy = CompatiblePointerDiscardsQualifiers; 3221 3222 if (!Context.typesAreBlockCompatible(lhptee, rhptee)) 3223 return IncompatibleBlockPointer; 3224 return ConvTy; 3225} 3226 3227/// CheckAssignmentConstraints (C99 6.5.16) - This routine currently 3228/// has code to accommodate several GCC extensions when type checking 3229/// pointers. Here are some objectionable examples that GCC considers warnings: 3230/// 3231/// int a, *pint; 3232/// short *pshort; 3233/// struct foo *pfoo; 3234/// 3235/// pint = pshort; // warning: assignment from incompatible pointer type 3236/// a = pint; // warning: assignment makes integer from pointer without a cast 3237/// pint = a; // warning: assignment makes pointer from integer without a cast 3238/// pint = pfoo; // warning: assignment from incompatible pointer type 3239/// 3240/// As a result, the code for dealing with pointers is more complex than the 3241/// C99 spec dictates. 3242/// 3243Sema::AssignConvertType 3244Sema::CheckAssignmentConstraints(QualType lhsType, QualType rhsType) { 3245 // Get canonical types. We're not formatting these types, just comparing 3246 // them. 3247 lhsType = Context.getCanonicalType(lhsType).getUnqualifiedType(); 3248 rhsType = Context.getCanonicalType(rhsType).getUnqualifiedType(); 3249 3250 if (lhsType == rhsType) 3251 return Compatible; // Common case: fast path an exact match. 3252 3253 // If the left-hand side is a reference type, then we are in a 3254 // (rare!) case where we've allowed the use of references in C, 3255 // e.g., as a parameter type in a built-in function. In this case, 3256 // just make sure that the type referenced is compatible with the 3257 // right-hand side type. The caller is responsible for adjusting 3258 // lhsType so that the resulting expression does not have reference 3259 // type. 3260 if (const ReferenceType *lhsTypeRef = lhsType->getAsReferenceType()) { 3261 if (Context.typesAreCompatible(lhsTypeRef->getPointeeType(), rhsType)) 3262 return Compatible; 3263 return Incompatible; 3264 } 3265 3266 if (lhsType->isObjCQualifiedIdType() || rhsType->isObjCQualifiedIdType()) { 3267 if (ObjCQualifiedIdTypesAreCompatible(lhsType, rhsType, false)) 3268 return Compatible; 3269 // Relax integer conversions like we do for pointers below. 3270 if (rhsType->isIntegerType()) 3271 return IntToPointer; 3272 if (lhsType->isIntegerType()) 3273 return PointerToInt; 3274 return IncompatibleObjCQualifiedId; 3275 } 3276 3277 if (lhsType->isVectorType() || rhsType->isVectorType()) { 3278 // For ExtVector, allow vector splats; float -> <n x float> 3279 if (const ExtVectorType *LV = lhsType->getAsExtVectorType()) 3280 if (LV->getElementType() == rhsType) 3281 return Compatible; 3282 3283 // If we are allowing lax vector conversions, and LHS and RHS are both 3284 // vectors, the total size only needs to be the same. This is a bitcast; 3285 // no bits are changed but the result type is different. 3286 if (getLangOptions().LaxVectorConversions && 3287 lhsType->isVectorType() && rhsType->isVectorType()) { 3288 if (Context.getTypeSize(lhsType) == Context.getTypeSize(rhsType)) 3289 return IncompatibleVectors; 3290 } 3291 return Incompatible; 3292 } 3293 3294 if (lhsType->isArithmeticType() && rhsType->isArithmeticType()) 3295 return Compatible; 3296 3297 if (isa<PointerType>(lhsType)) { 3298 if (rhsType->isIntegerType()) 3299 return IntToPointer; 3300 3301 if (isa<PointerType>(rhsType)) 3302 return CheckPointerTypesForAssignment(lhsType, rhsType); 3303 3304 if (rhsType->getAsBlockPointerType()) { 3305 if (lhsType->getAsPointerType()->getPointeeType()->isVoidType()) 3306 return Compatible; 3307 3308 // Treat block pointers as objects. 3309 if (getLangOptions().ObjC1 && 3310 lhsType == Context.getCanonicalType(Context.getObjCIdType())) 3311 return Compatible; 3312 } 3313 return Incompatible; 3314 } 3315 3316 if (isa<BlockPointerType>(lhsType)) { 3317 if (rhsType->isIntegerType()) 3318 return IntToBlockPointer; 3319 3320 // Treat block pointers as objects. 3321 if (getLangOptions().ObjC1 && 3322 rhsType == Context.getCanonicalType(Context.getObjCIdType())) 3323 return Compatible; 3324 3325 if (rhsType->isBlockPointerType()) 3326 return CheckBlockPointerTypesForAssignment(lhsType, rhsType); 3327 3328 if (const PointerType *RHSPT = rhsType->getAsPointerType()) { 3329 if (RHSPT->getPointeeType()->isVoidType()) 3330 return Compatible; 3331 } 3332 return Incompatible; 3333 } 3334 3335 if (isa<PointerType>(rhsType)) { 3336 // C99 6.5.16.1p1: the left operand is _Bool and the right is a pointer. 3337 if (lhsType == Context.BoolTy) 3338 return Compatible; 3339 3340 if (lhsType->isIntegerType()) 3341 return PointerToInt; 3342 3343 if (isa<PointerType>(lhsType)) 3344 return CheckPointerTypesForAssignment(lhsType, rhsType); 3345 3346 if (isa<BlockPointerType>(lhsType) && 3347 rhsType->getAsPointerType()->getPointeeType()->isVoidType()) 3348 return Compatible; 3349 return Incompatible; 3350 } 3351 3352 if (isa<TagType>(lhsType) && isa<TagType>(rhsType)) { 3353 if (Context.typesAreCompatible(lhsType, rhsType)) 3354 return Compatible; 3355 } 3356 return Incompatible; 3357} 3358 3359/// \brief Constructs a transparent union from an expression that is 3360/// used to initialize the transparent union. 3361static void ConstructTransparentUnion(ASTContext &C, Expr *&E, 3362 QualType UnionType, FieldDecl *Field) { 3363 // Build an initializer list that designates the appropriate member 3364 // of the transparent union. 3365 InitListExpr *Initializer = new (C) InitListExpr(SourceLocation(), 3366 &E, 1, 3367 SourceLocation()); 3368 Initializer->setType(UnionType); 3369 Initializer->setInitializedFieldInUnion(Field); 3370 3371 // Build a compound literal constructing a value of the transparent 3372 // union type from this initializer list. 3373 E = new (C) CompoundLiteralExpr(SourceLocation(), UnionType, Initializer, 3374 false); 3375} 3376 3377Sema::AssignConvertType 3378Sema::CheckTransparentUnionArgumentConstraints(QualType ArgType, Expr *&rExpr) { 3379 QualType FromType = rExpr->getType(); 3380 3381 // If the ArgType is a Union type, we want to handle a potential 3382 // transparent_union GCC extension. 3383 const RecordType *UT = ArgType->getAsUnionType(); 3384 if (!UT || !UT->getDecl()->hasAttr<TransparentUnionAttr>()) 3385 return Incompatible; 3386 3387 // The field to initialize within the transparent union. 3388 RecordDecl *UD = UT->getDecl(); 3389 FieldDecl *InitField = 0; 3390 // It's compatible if the expression matches any of the fields. 3391 for (RecordDecl::field_iterator it = UD->field_begin(Context), 3392 itend = UD->field_end(Context); 3393 it != itend; ++it) { 3394 if (it->getType()->isPointerType()) { 3395 // If the transparent union contains a pointer type, we allow: 3396 // 1) void pointer 3397 // 2) null pointer constant 3398 if (FromType->isPointerType()) 3399 if (FromType->getAsPointerType()->getPointeeType()->isVoidType()) { 3400 ImpCastExprToType(rExpr, it->getType()); 3401 InitField = *it; 3402 break; 3403 } 3404 3405 if (rExpr->isNullPointerConstant(Context)) { 3406 ImpCastExprToType(rExpr, it->getType()); 3407 InitField = *it; 3408 break; 3409 } 3410 } 3411 3412 if (CheckAssignmentConstraints(it->getType(), rExpr->getType()) 3413 == Compatible) { 3414 InitField = *it; 3415 break; 3416 } 3417 } 3418 3419 if (!InitField) 3420 return Incompatible; 3421 3422 ConstructTransparentUnion(Context, rExpr, ArgType, InitField); 3423 return Compatible; 3424} 3425 3426Sema::AssignConvertType 3427Sema::CheckSingleAssignmentConstraints(QualType lhsType, Expr *&rExpr) { 3428 if (getLangOptions().CPlusPlus) { 3429 if (!lhsType->isRecordType()) { 3430 // C++ 5.17p3: If the left operand is not of class type, the 3431 // expression is implicitly converted (C++ 4) to the 3432 // cv-unqualified type of the left operand. 3433 if (PerformImplicitConversion(rExpr, lhsType.getUnqualifiedType(), 3434 "assigning")) 3435 return Incompatible; 3436 return Compatible; 3437 } 3438 3439 // FIXME: Currently, we fall through and treat C++ classes like C 3440 // structures. 3441 } 3442 3443 // C99 6.5.16.1p1: the left operand is a pointer and the right is 3444 // a null pointer constant. 3445 if ((lhsType->isPointerType() || 3446 lhsType->isObjCQualifiedIdType() || 3447 lhsType->isBlockPointerType()) 3448 && rExpr->isNullPointerConstant(Context)) { 3449 ImpCastExprToType(rExpr, lhsType); 3450 return Compatible; 3451 } 3452 3453 // This check seems unnatural, however it is necessary to ensure the proper 3454 // conversion of functions/arrays. If the conversion were done for all 3455 // DeclExpr's (created by ActOnIdentifierExpr), it would mess up the unary 3456 // expressions that surpress this implicit conversion (&, sizeof). 3457 // 3458 // Suppress this for references: C++ 8.5.3p5. 3459 if (!lhsType->isReferenceType()) 3460 DefaultFunctionArrayConversion(rExpr); 3461 3462 Sema::AssignConvertType result = 3463 CheckAssignmentConstraints(lhsType, rExpr->getType()); 3464 3465 // C99 6.5.16.1p2: The value of the right operand is converted to the 3466 // type of the assignment expression. 3467 // CheckAssignmentConstraints allows the left-hand side to be a reference, 3468 // so that we can use references in built-in functions even in C. 3469 // The getNonReferenceType() call makes sure that the resulting expression 3470 // does not have reference type. 3471 if (result != Incompatible && rExpr->getType() != lhsType) 3472 ImpCastExprToType(rExpr, lhsType.getNonReferenceType()); 3473 return result; 3474} 3475 3476QualType Sema::InvalidOperands(SourceLocation Loc, Expr *&lex, Expr *&rex) { 3477 Diag(Loc, diag::err_typecheck_invalid_operands) 3478 << lex->getType() << rex->getType() 3479 << lex->getSourceRange() << rex->getSourceRange(); 3480 return QualType(); 3481} 3482 3483inline QualType Sema::CheckVectorOperands(SourceLocation Loc, Expr *&lex, 3484 Expr *&rex) { 3485 // For conversion purposes, we ignore any qualifiers. 3486 // For example, "const float" and "float" are equivalent. 3487 QualType lhsType = 3488 Context.getCanonicalType(lex->getType()).getUnqualifiedType(); 3489 QualType rhsType = 3490 Context.getCanonicalType(rex->getType()).getUnqualifiedType(); 3491 3492 // If the vector types are identical, return. 3493 if (lhsType == rhsType) 3494 return lhsType; 3495 3496 // Handle the case of a vector & extvector type of the same size and element 3497 // type. It would be nice if we only had one vector type someday. 3498 if (getLangOptions().LaxVectorConversions) { 3499 // FIXME: Should we warn here? 3500 if (const VectorType *LV = lhsType->getAsVectorType()) { 3501 if (const VectorType *RV = rhsType->getAsVectorType()) 3502 if (LV->getElementType() == RV->getElementType() && 3503 LV->getNumElements() == RV->getNumElements()) { 3504 return lhsType->isExtVectorType() ? lhsType : rhsType; 3505 } 3506 } 3507 } 3508 3509 // If the lhs is an extended vector and the rhs is a scalar of the same type 3510 // or a literal, promote the rhs to the vector type. 3511 if (const ExtVectorType *V = lhsType->getAsExtVectorType()) { 3512 QualType eltType = V->getElementType(); 3513 3514 if ((eltType->getAsBuiltinType() == rhsType->getAsBuiltinType()) || 3515 (eltType->isIntegerType() && isa<IntegerLiteral>(rex)) || 3516 (eltType->isFloatingType() && isa<FloatingLiteral>(rex))) { 3517 ImpCastExprToType(rex, lhsType); 3518 return lhsType; 3519 } 3520 } 3521 3522 // If the rhs is an extended vector and the lhs is a scalar of the same type, 3523 // promote the lhs to the vector type. 3524 if (const ExtVectorType *V = rhsType->getAsExtVectorType()) { 3525 QualType eltType = V->getElementType(); 3526 3527 if ((eltType->getAsBuiltinType() == lhsType->getAsBuiltinType()) || 3528 (eltType->isIntegerType() && isa<IntegerLiteral>(lex)) || 3529 (eltType->isFloatingType() && isa<FloatingLiteral>(lex))) { 3530 ImpCastExprToType(lex, rhsType); 3531 return rhsType; 3532 } 3533 } 3534 3535 // You cannot convert between vector values of different size. 3536 Diag(Loc, diag::err_typecheck_vector_not_convertable) 3537 << lex->getType() << rex->getType() 3538 << lex->getSourceRange() << rex->getSourceRange(); 3539 return QualType(); 3540} 3541 3542inline QualType Sema::CheckMultiplyDivideOperands( 3543 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign) 3544{ 3545 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) 3546 return CheckVectorOperands(Loc, lex, rex); 3547 3548 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign); 3549 3550 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType()) 3551 return compType; 3552 return InvalidOperands(Loc, lex, rex); 3553} 3554 3555inline QualType Sema::CheckRemainderOperands( 3556 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign) 3557{ 3558 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) { 3559 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType()) 3560 return CheckVectorOperands(Loc, lex, rex); 3561 return InvalidOperands(Loc, lex, rex); 3562 } 3563 3564 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign); 3565 3566 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType()) 3567 return compType; 3568 return InvalidOperands(Loc, lex, rex); 3569} 3570 3571inline QualType Sema::CheckAdditionOperands( // C99 6.5.6 3572 Expr *&lex, Expr *&rex, SourceLocation Loc, QualType* CompLHSTy) 3573{ 3574 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) { 3575 QualType compType = CheckVectorOperands(Loc, lex, rex); 3576 if (CompLHSTy) *CompLHSTy = compType; 3577 return compType; 3578 } 3579 3580 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy); 3581 3582 // handle the common case first (both operands are arithmetic). 3583 if (lex->getType()->isArithmeticType() && 3584 rex->getType()->isArithmeticType()) { 3585 if (CompLHSTy) *CompLHSTy = compType; 3586 return compType; 3587 } 3588 3589 // Put any potential pointer into PExp 3590 Expr* PExp = lex, *IExp = rex; 3591 if (IExp->getType()->isPointerType()) 3592 std::swap(PExp, IExp); 3593 3594 if (const PointerType *PTy = PExp->getType()->getAsPointerType()) { 3595 if (IExp->getType()->isIntegerType()) { 3596 QualType PointeeTy = PTy->getPointeeType(); 3597 // Check for arithmetic on pointers to incomplete types. 3598 if (PointeeTy->isVoidType()) { 3599 if (getLangOptions().CPlusPlus) { 3600 Diag(Loc, diag::err_typecheck_pointer_arith_void_type) 3601 << lex->getSourceRange() << rex->getSourceRange(); 3602 return QualType(); 3603 } 3604 3605 // GNU extension: arithmetic on pointer to void 3606 Diag(Loc, diag::ext_gnu_void_ptr) 3607 << lex->getSourceRange() << rex->getSourceRange(); 3608 } else if (PointeeTy->isFunctionType()) { 3609 if (getLangOptions().CPlusPlus) { 3610 Diag(Loc, diag::err_typecheck_pointer_arith_function_type) 3611 << lex->getType() << lex->getSourceRange(); 3612 return QualType(); 3613 } 3614 3615 // GNU extension: arithmetic on pointer to function 3616 Diag(Loc, diag::ext_gnu_ptr_func_arith) 3617 << lex->getType() << lex->getSourceRange(); 3618 } else if (!PTy->isDependentType() && 3619 RequireCompleteType(Loc, PointeeTy, 3620 diag::err_typecheck_arithmetic_incomplete_type, 3621 PExp->getSourceRange(), SourceRange(), 3622 PExp->getType())) 3623 return QualType(); 3624 3625 // Diagnose bad cases where we step over interface counts. 3626 if (PointeeTy->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) { 3627 Diag(Loc, diag::err_arithmetic_nonfragile_interface) 3628 << PointeeTy << PExp->getSourceRange(); 3629 return QualType(); 3630 } 3631 3632 if (CompLHSTy) { 3633 QualType LHSTy = lex->getType(); 3634 if (LHSTy->isPromotableIntegerType()) 3635 LHSTy = Context.IntTy; 3636 else { 3637 QualType T = isPromotableBitField(lex, Context); 3638 if (!T.isNull()) 3639 LHSTy = T; 3640 } 3641 3642 *CompLHSTy = LHSTy; 3643 } 3644 return PExp->getType(); 3645 } 3646 } 3647 3648 return InvalidOperands(Loc, lex, rex); 3649} 3650 3651// C99 6.5.6 3652QualType Sema::CheckSubtractionOperands(Expr *&lex, Expr *&rex, 3653 SourceLocation Loc, QualType* CompLHSTy) { 3654 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) { 3655 QualType compType = CheckVectorOperands(Loc, lex, rex); 3656 if (CompLHSTy) *CompLHSTy = compType; 3657 return compType; 3658 } 3659 3660 QualType compType = UsualArithmeticConversions(lex, rex, CompLHSTy); 3661 3662 // Enforce type constraints: C99 6.5.6p3. 3663 3664 // Handle the common case first (both operands are arithmetic). 3665 if (lex->getType()->isArithmeticType() 3666 && rex->getType()->isArithmeticType()) { 3667 if (CompLHSTy) *CompLHSTy = compType; 3668 return compType; 3669 } 3670 3671 // Either ptr - int or ptr - ptr. 3672 if (const PointerType *LHSPTy = lex->getType()->getAsPointerType()) { 3673 QualType lpointee = LHSPTy->getPointeeType(); 3674 3675 // The LHS must be an completely-defined object type. 3676 3677 bool ComplainAboutVoid = false; 3678 Expr *ComplainAboutFunc = 0; 3679 if (lpointee->isVoidType()) { 3680 if (getLangOptions().CPlusPlus) { 3681 Diag(Loc, diag::err_typecheck_pointer_arith_void_type) 3682 << lex->getSourceRange() << rex->getSourceRange(); 3683 return QualType(); 3684 } 3685 3686 // GNU C extension: arithmetic on pointer to void 3687 ComplainAboutVoid = true; 3688 } else if (lpointee->isFunctionType()) { 3689 if (getLangOptions().CPlusPlus) { 3690 Diag(Loc, diag::err_typecheck_pointer_arith_function_type) 3691 << lex->getType() << lex->getSourceRange(); 3692 return QualType(); 3693 } 3694 3695 // GNU C extension: arithmetic on pointer to function 3696 ComplainAboutFunc = lex; 3697 } else if (!lpointee->isDependentType() && 3698 RequireCompleteType(Loc, lpointee, 3699 diag::err_typecheck_sub_ptr_object, 3700 lex->getSourceRange(), 3701 SourceRange(), 3702 lex->getType())) 3703 return QualType(); 3704 3705 // Diagnose bad cases where we step over interface counts. 3706 if (lpointee->isObjCInterfaceType() && LangOpts.ObjCNonFragileABI) { 3707 Diag(Loc, diag::err_arithmetic_nonfragile_interface) 3708 << lpointee << lex->getSourceRange(); 3709 return QualType(); 3710 } 3711 3712 // The result type of a pointer-int computation is the pointer type. 3713 if (rex->getType()->isIntegerType()) { 3714 if (ComplainAboutVoid) 3715 Diag(Loc, diag::ext_gnu_void_ptr) 3716 << lex->getSourceRange() << rex->getSourceRange(); 3717 if (ComplainAboutFunc) 3718 Diag(Loc, diag::ext_gnu_ptr_func_arith) 3719 << ComplainAboutFunc->getType() 3720 << ComplainAboutFunc->getSourceRange(); 3721 3722 if (CompLHSTy) *CompLHSTy = lex->getType(); 3723 return lex->getType(); 3724 } 3725 3726 // Handle pointer-pointer subtractions. 3727 if (const PointerType *RHSPTy = rex->getType()->getAsPointerType()) { 3728 QualType rpointee = RHSPTy->getPointeeType(); 3729 3730 // RHS must be a completely-type object type. 3731 // Handle the GNU void* extension. 3732 if (rpointee->isVoidType()) { 3733 if (getLangOptions().CPlusPlus) { 3734 Diag(Loc, diag::err_typecheck_pointer_arith_void_type) 3735 << lex->getSourceRange() << rex->getSourceRange(); 3736 return QualType(); 3737 } 3738 3739 ComplainAboutVoid = true; 3740 } else if (rpointee->isFunctionType()) { 3741 if (getLangOptions().CPlusPlus) { 3742 Diag(Loc, diag::err_typecheck_pointer_arith_function_type) 3743 << rex->getType() << rex->getSourceRange(); 3744 return QualType(); 3745 } 3746 3747 // GNU extension: arithmetic on pointer to function 3748 if (!ComplainAboutFunc) 3749 ComplainAboutFunc = rex; 3750 } else if (!rpointee->isDependentType() && 3751 RequireCompleteType(Loc, rpointee, 3752 diag::err_typecheck_sub_ptr_object, 3753 rex->getSourceRange(), 3754 SourceRange(), 3755 rex->getType())) 3756 return QualType(); 3757 3758 if (getLangOptions().CPlusPlus) { 3759 // Pointee types must be the same: C++ [expr.add] 3760 if (!Context.hasSameUnqualifiedType(lpointee, rpointee)) { 3761 Diag(Loc, diag::err_typecheck_sub_ptr_compatible) 3762 << lex->getType() << rex->getType() 3763 << lex->getSourceRange() << rex->getSourceRange(); 3764 return QualType(); 3765 } 3766 } else { 3767 // Pointee types must be compatible C99 6.5.6p3 3768 if (!Context.typesAreCompatible( 3769 Context.getCanonicalType(lpointee).getUnqualifiedType(), 3770 Context.getCanonicalType(rpointee).getUnqualifiedType())) { 3771 Diag(Loc, diag::err_typecheck_sub_ptr_compatible) 3772 << lex->getType() << rex->getType() 3773 << lex->getSourceRange() << rex->getSourceRange(); 3774 return QualType(); 3775 } 3776 } 3777 3778 if (ComplainAboutVoid) 3779 Diag(Loc, diag::ext_gnu_void_ptr) 3780 << lex->getSourceRange() << rex->getSourceRange(); 3781 if (ComplainAboutFunc) 3782 Diag(Loc, diag::ext_gnu_ptr_func_arith) 3783 << ComplainAboutFunc->getType() 3784 << ComplainAboutFunc->getSourceRange(); 3785 3786 if (CompLHSTy) *CompLHSTy = lex->getType(); 3787 return Context.getPointerDiffType(); 3788 } 3789 } 3790 3791 return InvalidOperands(Loc, lex, rex); 3792} 3793 3794// C99 6.5.7 3795QualType Sema::CheckShiftOperands(Expr *&lex, Expr *&rex, SourceLocation Loc, 3796 bool isCompAssign) { 3797 // C99 6.5.7p2: Each of the operands shall have integer type. 3798 if (!lex->getType()->isIntegerType() || !rex->getType()->isIntegerType()) 3799 return InvalidOperands(Loc, lex, rex); 3800 3801 // Shifts don't perform usual arithmetic conversions, they just do integer 3802 // promotions on each operand. C99 6.5.7p3 3803 QualType LHSTy; 3804 if (lex->getType()->isPromotableIntegerType()) 3805 LHSTy = Context.IntTy; 3806 else { 3807 LHSTy = isPromotableBitField(lex, Context); 3808 if (LHSTy.isNull()) 3809 LHSTy = lex->getType(); 3810 } 3811 if (!isCompAssign) 3812 ImpCastExprToType(lex, LHSTy); 3813 3814 UsualUnaryConversions(rex); 3815 3816 // "The type of the result is that of the promoted left operand." 3817 return LHSTy; 3818} 3819 3820// C99 6.5.8, C++ [expr.rel] 3821QualType Sema::CheckCompareOperands(Expr *&lex, Expr *&rex, SourceLocation Loc, 3822 unsigned OpaqueOpc, bool isRelational) { 3823 BinaryOperator::Opcode Opc = (BinaryOperator::Opcode)OpaqueOpc; 3824 3825 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) 3826 return CheckVectorCompareOperands(lex, rex, Loc, isRelational); 3827 3828 // C99 6.5.8p3 / C99 6.5.9p4 3829 if (lex->getType()->isArithmeticType() && rex->getType()->isArithmeticType()) 3830 UsualArithmeticConversions(lex, rex); 3831 else { 3832 UsualUnaryConversions(lex); 3833 UsualUnaryConversions(rex); 3834 } 3835 QualType lType = lex->getType(); 3836 QualType rType = rex->getType(); 3837 3838 if (!lType->isFloatingType() 3839 && !(lType->isBlockPointerType() && isRelational)) { 3840 // For non-floating point types, check for self-comparisons of the form 3841 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 3842 // often indicate logic errors in the program. 3843 // NOTE: Don't warn about comparisons of enum constants. These can arise 3844 // from macro expansions, and are usually quite deliberate. 3845 Expr *LHSStripped = lex->IgnoreParens(); 3846 Expr *RHSStripped = rex->IgnoreParens(); 3847 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(LHSStripped)) 3848 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(RHSStripped)) 3849 if (DRL->getDecl() == DRR->getDecl() && 3850 !isa<EnumConstantDecl>(DRL->getDecl())) 3851 Diag(Loc, diag::warn_selfcomparison); 3852 3853 if (isa<CastExpr>(LHSStripped)) 3854 LHSStripped = LHSStripped->IgnoreParenCasts(); 3855 if (isa<CastExpr>(RHSStripped)) 3856 RHSStripped = RHSStripped->IgnoreParenCasts(); 3857 3858 // Warn about comparisons against a string constant (unless the other 3859 // operand is null), the user probably wants strcmp. 3860 Expr *literalString = 0; 3861 Expr *literalStringStripped = 0; 3862 if ((isa<StringLiteral>(LHSStripped) || isa<ObjCEncodeExpr>(LHSStripped)) && 3863 !RHSStripped->isNullPointerConstant(Context)) { 3864 literalString = lex; 3865 literalStringStripped = LHSStripped; 3866 } 3867 else if ((isa<StringLiteral>(RHSStripped) || 3868 isa<ObjCEncodeExpr>(RHSStripped)) && 3869 !LHSStripped->isNullPointerConstant(Context)) { 3870 literalString = rex; 3871 literalStringStripped = RHSStripped; 3872 } 3873 3874 if (literalString) { 3875 std::string resultComparison; 3876 switch (Opc) { 3877 case BinaryOperator::LT: resultComparison = ") < 0"; break; 3878 case BinaryOperator::GT: resultComparison = ") > 0"; break; 3879 case BinaryOperator::LE: resultComparison = ") <= 0"; break; 3880 case BinaryOperator::GE: resultComparison = ") >= 0"; break; 3881 case BinaryOperator::EQ: resultComparison = ") == 0"; break; 3882 case BinaryOperator::NE: resultComparison = ") != 0"; break; 3883 default: assert(false && "Invalid comparison operator"); 3884 } 3885 Diag(Loc, diag::warn_stringcompare) 3886 << isa<ObjCEncodeExpr>(literalStringStripped) 3887 << literalString->getSourceRange() 3888 << CodeModificationHint::CreateReplacement(SourceRange(Loc), ", ") 3889 << CodeModificationHint::CreateInsertion(lex->getLocStart(), 3890 "strcmp(") 3891 << CodeModificationHint::CreateInsertion( 3892 PP.getLocForEndOfToken(rex->getLocEnd()), 3893 resultComparison); 3894 } 3895 } 3896 3897 // The result of comparisons is 'bool' in C++, 'int' in C. 3898 QualType ResultTy = getLangOptions().CPlusPlus? Context.BoolTy :Context.IntTy; 3899 3900 if (isRelational) { 3901 if (lType->isRealType() && rType->isRealType()) 3902 return ResultTy; 3903 } else { 3904 // Check for comparisons of floating point operands using != and ==. 3905 if (lType->isFloatingType()) { 3906 assert(rType->isFloatingType()); 3907 CheckFloatComparison(Loc,lex,rex); 3908 } 3909 3910 if (lType->isArithmeticType() && rType->isArithmeticType()) 3911 return ResultTy; 3912 } 3913 3914 bool LHSIsNull = lex->isNullPointerConstant(Context); 3915 bool RHSIsNull = rex->isNullPointerConstant(Context); 3916 3917 // All of the following pointer related warnings are GCC extensions, except 3918 // when handling null pointer constants. One day, we can consider making them 3919 // errors (when -pedantic-errors is enabled). 3920 if (lType->isPointerType() && rType->isPointerType()) { // C99 6.5.8p2 3921 QualType LCanPointeeTy = 3922 Context.getCanonicalType(lType->getAsPointerType()->getPointeeType()); 3923 QualType RCanPointeeTy = 3924 Context.getCanonicalType(rType->getAsPointerType()->getPointeeType()); 3925 3926 // Simple check: if the pointee types are identical, we're done. 3927 if (LCanPointeeTy == RCanPointeeTy) 3928 return ResultTy; 3929 3930 if (getLangOptions().CPlusPlus) { 3931 // C++ [expr.rel]p2: 3932 // [...] Pointer conversions (4.10) and qualification 3933 // conversions (4.4) are performed on pointer operands (or on 3934 // a pointer operand and a null pointer constant) to bring 3935 // them to their composite pointer type. [...] 3936 // 3937 // C++ [expr.eq]p2 uses the same notion for (in)equality 3938 // comparisons of pointers. 3939 QualType T = FindCompositePointerType(lex, rex); 3940 if (T.isNull()) { 3941 Diag(Loc, diag::err_typecheck_comparison_of_distinct_pointers) 3942 << lType << rType << lex->getSourceRange() << rex->getSourceRange(); 3943 return QualType(); 3944 } 3945 3946 ImpCastExprToType(lex, T); 3947 ImpCastExprToType(rex, T); 3948 return ResultTy; 3949 } 3950 3951 if (!LHSIsNull && !RHSIsNull && // C99 6.5.9p2 3952 !LCanPointeeTy->isVoidType() && !RCanPointeeTy->isVoidType() && 3953 !Context.typesAreCompatible(LCanPointeeTy.getUnqualifiedType(), 3954 RCanPointeeTy.getUnqualifiedType()) && 3955 !Context.areComparableObjCPointerTypes(lType, rType)) { 3956 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers) 3957 << lType << rType << lex->getSourceRange() << rex->getSourceRange(); 3958 } 3959 ImpCastExprToType(rex, lType); // promote the pointer to pointer 3960 return ResultTy; 3961 } 3962 // C++ allows comparison of pointers with null pointer constants. 3963 if (getLangOptions().CPlusPlus) { 3964 if (lType->isPointerType() && RHSIsNull) { 3965 ImpCastExprToType(rex, lType); 3966 return ResultTy; 3967 } 3968 if (rType->isPointerType() && LHSIsNull) { 3969 ImpCastExprToType(lex, rType); 3970 return ResultTy; 3971 } 3972 // And comparison of nullptr_t with itself. 3973 if (lType->isNullPtrType() && rType->isNullPtrType()) 3974 return ResultTy; 3975 } 3976 // Handle block pointer types. 3977 if (!isRelational && lType->isBlockPointerType() && rType->isBlockPointerType()) { 3978 QualType lpointee = lType->getAsBlockPointerType()->getPointeeType(); 3979 QualType rpointee = rType->getAsBlockPointerType()->getPointeeType(); 3980 3981 if (!LHSIsNull && !RHSIsNull && 3982 !Context.typesAreBlockCompatible(lpointee, rpointee)) { 3983 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 3984 << lType << rType << lex->getSourceRange() << rex->getSourceRange(); 3985 } 3986 ImpCastExprToType(rex, lType); // promote the pointer to pointer 3987 return ResultTy; 3988 } 3989 // Allow block pointers to be compared with null pointer constants. 3990 if (!isRelational 3991 && ((lType->isBlockPointerType() && rType->isPointerType()) 3992 || (lType->isPointerType() && rType->isBlockPointerType()))) { 3993 if (!LHSIsNull && !RHSIsNull) { 3994 if (!((rType->isPointerType() && rType->getAsPointerType() 3995 ->getPointeeType()->isVoidType()) 3996 || (lType->isPointerType() && lType->getAsPointerType() 3997 ->getPointeeType()->isVoidType()))) 3998 Diag(Loc, diag::err_typecheck_comparison_of_distinct_blocks) 3999 << lType << rType << lex->getSourceRange() << rex->getSourceRange(); 4000 } 4001 ImpCastExprToType(rex, lType); // promote the pointer to pointer 4002 return ResultTy; 4003 } 4004 4005 if ((lType->isObjCQualifiedIdType() || rType->isObjCQualifiedIdType())) { 4006 if (lType->isPointerType() || rType->isPointerType()) { 4007 const PointerType *LPT = lType->getAsPointerType(); 4008 const PointerType *RPT = rType->getAsPointerType(); 4009 bool LPtrToVoid = LPT ? 4010 Context.getCanonicalType(LPT->getPointeeType())->isVoidType() : false; 4011 bool RPtrToVoid = RPT ? 4012 Context.getCanonicalType(RPT->getPointeeType())->isVoidType() : false; 4013 4014 if (!LPtrToVoid && !RPtrToVoid && 4015 !Context.typesAreCompatible(lType, rType)) { 4016 Diag(Loc, diag::ext_typecheck_comparison_of_distinct_pointers) 4017 << lType << rType << lex->getSourceRange() << rex->getSourceRange(); 4018 ImpCastExprToType(rex, lType); 4019 return ResultTy; 4020 } 4021 ImpCastExprToType(rex, lType); 4022 return ResultTy; 4023 } 4024 if (ObjCQualifiedIdTypesAreCompatible(lType, rType, true)) { 4025 ImpCastExprToType(rex, lType); 4026 return ResultTy; 4027 } else { 4028 if ((lType->isObjCQualifiedIdType() && rType->isObjCQualifiedIdType())) { 4029 Diag(Loc, diag::warn_incompatible_qualified_id_operands) 4030 << lType << rType << lex->getSourceRange() << rex->getSourceRange(); 4031 ImpCastExprToType(rex, lType); 4032 return ResultTy; 4033 } 4034 } 4035 } 4036 if ((lType->isPointerType() || lType->isObjCQualifiedIdType()) && 4037 rType->isIntegerType()) { 4038 if (!RHSIsNull) 4039 Diag(Loc, diag::ext_typecheck_comparison_of_pointer_integer) 4040 << lType << rType << lex->getSourceRange() << rex->getSourceRange(); 4041 ImpCastExprToType(rex, lType); // promote the integer to pointer 4042 return ResultTy; 4043 } 4044 if (lType->isIntegerType() && 4045 (rType->isPointerType() || rType->isObjCQualifiedIdType())) { 4046 if (!LHSIsNull) 4047 Diag(Loc, diag::ext_typecheck_comparison_of_pointer_integer) 4048 << lType << rType << lex->getSourceRange() << rex->getSourceRange(); 4049 ImpCastExprToType(lex, rType); // promote the integer to pointer 4050 return ResultTy; 4051 } 4052 // Handle block pointers. 4053 if (!isRelational && RHSIsNull 4054 && lType->isBlockPointerType() && rType->isIntegerType()) { 4055 ImpCastExprToType(rex, lType); // promote the integer to pointer 4056 return ResultTy; 4057 } 4058 if (!isRelational && LHSIsNull 4059 && lType->isIntegerType() && rType->isBlockPointerType()) { 4060 ImpCastExprToType(lex, rType); // promote the integer to pointer 4061 return ResultTy; 4062 } 4063 return InvalidOperands(Loc, lex, rex); 4064} 4065 4066/// CheckVectorCompareOperands - vector comparisons are a clang extension that 4067/// operates on extended vector types. Instead of producing an IntTy result, 4068/// like a scalar comparison, a vector comparison produces a vector of integer 4069/// types. 4070QualType Sema::CheckVectorCompareOperands(Expr *&lex, Expr *&rex, 4071 SourceLocation Loc, 4072 bool isRelational) { 4073 // Check to make sure we're operating on vectors of the same type and width, 4074 // Allowing one side to be a scalar of element type. 4075 QualType vType = CheckVectorOperands(Loc, lex, rex); 4076 if (vType.isNull()) 4077 return vType; 4078 4079 QualType lType = lex->getType(); 4080 QualType rType = rex->getType(); 4081 4082 // For non-floating point types, check for self-comparisons of the form 4083 // x == x, x != x, x < x, etc. These always evaluate to a constant, and 4084 // often indicate logic errors in the program. 4085 if (!lType->isFloatingType()) { 4086 if (DeclRefExpr* DRL = dyn_cast<DeclRefExpr>(lex->IgnoreParens())) 4087 if (DeclRefExpr* DRR = dyn_cast<DeclRefExpr>(rex->IgnoreParens())) 4088 if (DRL->getDecl() == DRR->getDecl()) 4089 Diag(Loc, diag::warn_selfcomparison); 4090 } 4091 4092 // Check for comparisons of floating point operands using != and ==. 4093 if (!isRelational && lType->isFloatingType()) { 4094 assert (rType->isFloatingType()); 4095 CheckFloatComparison(Loc,lex,rex); 4096 } 4097 4098 // FIXME: Vector compare support in the LLVM backend is not fully reliable, 4099 // just reject all vector comparisons for now. 4100 if (1) { 4101 Diag(Loc, diag::err_typecheck_vector_comparison) 4102 << lType << rType << lex->getSourceRange() << rex->getSourceRange(); 4103 return QualType(); 4104 } 4105 4106 // Return the type for the comparison, which is the same as vector type for 4107 // integer vectors, or an integer type of identical size and number of 4108 // elements for floating point vectors. 4109 if (lType->isIntegerType()) 4110 return lType; 4111 4112 const VectorType *VTy = lType->getAsVectorType(); 4113 unsigned TypeSize = Context.getTypeSize(VTy->getElementType()); 4114 if (TypeSize == Context.getTypeSize(Context.IntTy)) 4115 return Context.getExtVectorType(Context.IntTy, VTy->getNumElements()); 4116 if (TypeSize == Context.getTypeSize(Context.LongTy)) 4117 return Context.getExtVectorType(Context.LongTy, VTy->getNumElements()); 4118 4119 assert(TypeSize == Context.getTypeSize(Context.LongLongTy) && 4120 "Unhandled vector element size in vector compare"); 4121 return Context.getExtVectorType(Context.LongLongTy, VTy->getNumElements()); 4122} 4123 4124inline QualType Sema::CheckBitwiseOperands( 4125 Expr *&lex, Expr *&rex, SourceLocation Loc, bool isCompAssign) 4126{ 4127 if (lex->getType()->isVectorType() || rex->getType()->isVectorType()) 4128 return CheckVectorOperands(Loc, lex, rex); 4129 4130 QualType compType = UsualArithmeticConversions(lex, rex, isCompAssign); 4131 4132 if (lex->getType()->isIntegerType() && rex->getType()->isIntegerType()) 4133 return compType; 4134 return InvalidOperands(Loc, lex, rex); 4135} 4136 4137inline QualType Sema::CheckLogicalOperands( // C99 6.5.[13,14] 4138 Expr *&lex, Expr *&rex, SourceLocation Loc) 4139{ 4140 UsualUnaryConversions(lex); 4141 UsualUnaryConversions(rex); 4142 4143 if (lex->getType()->isScalarType() && rex->getType()->isScalarType()) 4144 return Context.IntTy; 4145 return InvalidOperands(Loc, lex, rex); 4146} 4147 4148/// IsReadonlyProperty - Verify that otherwise a valid l-value expression 4149/// is a read-only property; return true if so. A readonly property expression 4150/// depends on various declarations and thus must be treated specially. 4151/// 4152static bool IsReadonlyProperty(Expr *E, Sema &S) 4153{ 4154 if (E->getStmtClass() == Expr::ObjCPropertyRefExprClass) { 4155 const ObjCPropertyRefExpr* PropExpr = cast<ObjCPropertyRefExpr>(E); 4156 if (ObjCPropertyDecl *PDecl = PropExpr->getProperty()) { 4157 QualType BaseType = PropExpr->getBase()->getType(); 4158 if (const PointerType *PTy = BaseType->getAsPointerType()) 4159 if (const ObjCInterfaceType *IFTy = 4160 PTy->getPointeeType()->getAsObjCInterfaceType()) 4161 if (ObjCInterfaceDecl *IFace = IFTy->getDecl()) 4162 if (S.isPropertyReadonly(PDecl, IFace)) 4163 return true; 4164 } 4165 } 4166 return false; 4167} 4168 4169/// CheckForModifiableLvalue - Verify that E is a modifiable lvalue. If not, 4170/// emit an error and return true. If so, return false. 4171static bool CheckForModifiableLvalue(Expr *E, SourceLocation Loc, Sema &S) { 4172 SourceLocation OrigLoc = Loc; 4173 Expr::isModifiableLvalueResult IsLV = E->isModifiableLvalue(S.Context, 4174 &Loc); 4175 if (IsLV == Expr::MLV_Valid && IsReadonlyProperty(E, S)) 4176 IsLV = Expr::MLV_ReadonlyProperty; 4177 if (IsLV == Expr::MLV_Valid) 4178 return false; 4179 4180 unsigned Diag = 0; 4181 bool NeedType = false; 4182 switch (IsLV) { // C99 6.5.16p2 4183 default: assert(0 && "Unknown result from isModifiableLvalue!"); 4184 case Expr::MLV_ConstQualified: Diag = diag::err_typecheck_assign_const; break; 4185 case Expr::MLV_ArrayType: 4186 Diag = diag::err_typecheck_array_not_modifiable_lvalue; 4187 NeedType = true; 4188 break; 4189 case Expr::MLV_NotObjectType: 4190 Diag = diag::err_typecheck_non_object_not_modifiable_lvalue; 4191 NeedType = true; 4192 break; 4193 case Expr::MLV_LValueCast: 4194 Diag = diag::err_typecheck_lvalue_casts_not_supported; 4195 break; 4196 case Expr::MLV_InvalidExpression: 4197 Diag = diag::err_typecheck_expression_not_modifiable_lvalue; 4198 break; 4199 case Expr::MLV_IncompleteType: 4200 case Expr::MLV_IncompleteVoidType: 4201 return S.RequireCompleteType(Loc, E->getType(), 4202 diag::err_typecheck_incomplete_type_not_modifiable_lvalue, 4203 E->getSourceRange()); 4204 case Expr::MLV_DuplicateVectorComponents: 4205 Diag = diag::err_typecheck_duplicate_vector_components_not_mlvalue; 4206 break; 4207 case Expr::MLV_NotBlockQualified: 4208 Diag = diag::err_block_decl_ref_not_modifiable_lvalue; 4209 break; 4210 case Expr::MLV_ReadonlyProperty: 4211 Diag = diag::error_readonly_property_assignment; 4212 break; 4213 case Expr::MLV_NoSetterProperty: 4214 Diag = diag::error_nosetter_property_assignment; 4215 break; 4216 } 4217 4218 SourceRange Assign; 4219 if (Loc != OrigLoc) 4220 Assign = SourceRange(OrigLoc, OrigLoc); 4221 if (NeedType) 4222 S.Diag(Loc, Diag) << E->getType() << E->getSourceRange() << Assign; 4223 else 4224 S.Diag(Loc, Diag) << E->getSourceRange() << Assign; 4225 return true; 4226} 4227 4228 4229 4230// C99 6.5.16.1 4231QualType Sema::CheckAssignmentOperands(Expr *LHS, Expr *&RHS, 4232 SourceLocation Loc, 4233 QualType CompoundType) { 4234 // Verify that LHS is a modifiable lvalue, and emit error if not. 4235 if (CheckForModifiableLvalue(LHS, Loc, *this)) 4236 return QualType(); 4237 4238 QualType LHSType = LHS->getType(); 4239 QualType RHSType = CompoundType.isNull() ? RHS->getType() : CompoundType; 4240 4241 AssignConvertType ConvTy; 4242 if (CompoundType.isNull()) { 4243 // Simple assignment "x = y". 4244 ConvTy = CheckSingleAssignmentConstraints(LHSType, RHS); 4245 // Special case of NSObject attributes on c-style pointer types. 4246 if (ConvTy == IncompatiblePointer && 4247 ((Context.isObjCNSObjectType(LHSType) && 4248 Context.isObjCObjectPointerType(RHSType)) || 4249 (Context.isObjCNSObjectType(RHSType) && 4250 Context.isObjCObjectPointerType(LHSType)))) 4251 ConvTy = Compatible; 4252 4253 // If the RHS is a unary plus or minus, check to see if they = and + are 4254 // right next to each other. If so, the user may have typo'd "x =+ 4" 4255 // instead of "x += 4". 4256 Expr *RHSCheck = RHS; 4257 if (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(RHSCheck)) 4258 RHSCheck = ICE->getSubExpr(); 4259 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(RHSCheck)) { 4260 if ((UO->getOpcode() == UnaryOperator::Plus || 4261 UO->getOpcode() == UnaryOperator::Minus) && 4262 Loc.isFileID() && UO->getOperatorLoc().isFileID() && 4263 // Only if the two operators are exactly adjacent. 4264 Loc.getFileLocWithOffset(1) == UO->getOperatorLoc() && 4265 // And there is a space or other character before the subexpr of the 4266 // unary +/-. We don't want to warn on "x=-1". 4267 Loc.getFileLocWithOffset(2) != UO->getSubExpr()->getLocStart() && 4268 UO->getSubExpr()->getLocStart().isFileID()) { 4269 Diag(Loc, diag::warn_not_compound_assign) 4270 << (UO->getOpcode() == UnaryOperator::Plus ? "+" : "-") 4271 << SourceRange(UO->getOperatorLoc(), UO->getOperatorLoc()); 4272 } 4273 } 4274 } else { 4275 // Compound assignment "x += y" 4276 ConvTy = CheckAssignmentConstraints(LHSType, RHSType); 4277 } 4278 4279 if (DiagnoseAssignmentResult(ConvTy, Loc, LHSType, RHSType, 4280 RHS, "assigning")) 4281 return QualType(); 4282 4283 // C99 6.5.16p3: The type of an assignment expression is the type of the 4284 // left operand unless the left operand has qualified type, in which case 4285 // it is the unqualified version of the type of the left operand. 4286 // C99 6.5.16.1p2: In simple assignment, the value of the right operand 4287 // is converted to the type of the assignment expression (above). 4288 // C++ 5.17p1: the type of the assignment expression is that of its left 4289 // operand. 4290 return LHSType.getUnqualifiedType(); 4291} 4292 4293// C99 6.5.17 4294QualType Sema::CheckCommaOperands(Expr *LHS, Expr *&RHS, SourceLocation Loc) { 4295 // Comma performs lvalue conversion (C99 6.3.2.1), but not unary conversions. 4296 DefaultFunctionArrayConversion(RHS); 4297 4298 // FIXME: Check that RHS type is complete in C mode (it's legal for it to be 4299 // incomplete in C++). 4300 4301 return RHS->getType(); 4302} 4303 4304/// CheckIncrementDecrementOperand - unlike most "Check" methods, this routine 4305/// doesn't need to call UsualUnaryConversions or UsualArithmeticConversions. 4306QualType Sema::CheckIncrementDecrementOperand(Expr *Op, SourceLocation OpLoc, 4307 bool isInc) { 4308 if (Op->isTypeDependent()) 4309 return Context.DependentTy; 4310 4311 QualType ResType = Op->getType(); 4312 assert(!ResType.isNull() && "no type for increment/decrement expression"); 4313 4314 if (getLangOptions().CPlusPlus && ResType->isBooleanType()) { 4315 // Decrement of bool is not allowed. 4316 if (!isInc) { 4317 Diag(OpLoc, diag::err_decrement_bool) << Op->getSourceRange(); 4318 return QualType(); 4319 } 4320 // Increment of bool sets it to true, but is deprecated. 4321 Diag(OpLoc, diag::warn_increment_bool) << Op->getSourceRange(); 4322 } else if (ResType->isRealType()) { 4323 // OK! 4324 } else if (const PointerType *PT = ResType->getAsPointerType()) { 4325 // C99 6.5.2.4p2, 6.5.6p2 4326 if (PT->getPointeeType()->isVoidType()) { 4327 if (getLangOptions().CPlusPlus) { 4328 Diag(OpLoc, diag::err_typecheck_pointer_arith_void_type) 4329 << Op->getSourceRange(); 4330 return QualType(); 4331 } 4332 4333 // Pointer to void is a GNU extension in C. 4334 Diag(OpLoc, diag::ext_gnu_void_ptr) << Op->getSourceRange(); 4335 } else if (PT->getPointeeType()->isFunctionType()) { 4336 if (getLangOptions().CPlusPlus) { 4337 Diag(OpLoc, diag::err_typecheck_pointer_arith_function_type) 4338 << Op->getType() << Op->getSourceRange(); 4339 return QualType(); 4340 } 4341 4342 Diag(OpLoc, diag::ext_gnu_ptr_func_arith) 4343 << ResType << Op->getSourceRange(); 4344 } else if (RequireCompleteType(OpLoc, PT->getPointeeType(), 4345 diag::err_typecheck_arithmetic_incomplete_type, 4346 Op->getSourceRange(), SourceRange(), 4347 ResType)) 4348 return QualType(); 4349 } else if (ResType->isComplexType()) { 4350 // C99 does not support ++/-- on complex types, we allow as an extension. 4351 Diag(OpLoc, diag::ext_integer_increment_complex) 4352 << ResType << Op->getSourceRange(); 4353 } else { 4354 Diag(OpLoc, diag::err_typecheck_illegal_increment_decrement) 4355 << ResType << Op->getSourceRange(); 4356 return QualType(); 4357 } 4358 // At this point, we know we have a real, complex or pointer type. 4359 // Now make sure the operand is a modifiable lvalue. 4360 if (CheckForModifiableLvalue(Op, OpLoc, *this)) 4361 return QualType(); 4362 return ResType; 4363} 4364 4365/// getPrimaryDecl - Helper function for CheckAddressOfOperand(). 4366/// This routine allows us to typecheck complex/recursive expressions 4367/// where the declaration is needed for type checking. We only need to 4368/// handle cases when the expression references a function designator 4369/// or is an lvalue. Here are some examples: 4370/// - &(x) => x 4371/// - &*****f => f for f a function designator. 4372/// - &s.xx => s 4373/// - &s.zz[1].yy -> s, if zz is an array 4374/// - *(x + 1) -> x, if x is an array 4375/// - &"123"[2] -> 0 4376/// - & __real__ x -> x 4377static NamedDecl *getPrimaryDecl(Expr *E) { 4378 switch (E->getStmtClass()) { 4379 case Stmt::DeclRefExprClass: 4380 case Stmt::QualifiedDeclRefExprClass: 4381 return cast<DeclRefExpr>(E)->getDecl(); 4382 case Stmt::MemberExprClass: 4383 // If this is an arrow operator, the address is an offset from 4384 // the base's value, so the object the base refers to is 4385 // irrelevant. 4386 if (cast<MemberExpr>(E)->isArrow()) 4387 return 0; 4388 // Otherwise, the expression refers to a part of the base 4389 return getPrimaryDecl(cast<MemberExpr>(E)->getBase()); 4390 case Stmt::ArraySubscriptExprClass: { 4391 // FIXME: This code shouldn't be necessary! We should catch the implicit 4392 // promotion of register arrays earlier. 4393 Expr* Base = cast<ArraySubscriptExpr>(E)->getBase(); 4394 if (ImplicitCastExpr* ICE = dyn_cast<ImplicitCastExpr>(Base)) { 4395 if (ICE->getSubExpr()->getType()->isArrayType()) 4396 return getPrimaryDecl(ICE->getSubExpr()); 4397 } 4398 return 0; 4399 } 4400 case Stmt::UnaryOperatorClass: { 4401 UnaryOperator *UO = cast<UnaryOperator>(E); 4402 4403 switch(UO->getOpcode()) { 4404 case UnaryOperator::Real: 4405 case UnaryOperator::Imag: 4406 case UnaryOperator::Extension: 4407 return getPrimaryDecl(UO->getSubExpr()); 4408 default: 4409 return 0; 4410 } 4411 } 4412 case Stmt::ParenExprClass: 4413 return getPrimaryDecl(cast<ParenExpr>(E)->getSubExpr()); 4414 case Stmt::ImplicitCastExprClass: 4415 // If the result of an implicit cast is an l-value, we care about 4416 // the sub-expression; otherwise, the result here doesn't matter. 4417 return getPrimaryDecl(cast<ImplicitCastExpr>(E)->getSubExpr()); 4418 default: 4419 return 0; 4420 } 4421} 4422 4423/// CheckAddressOfOperand - The operand of & must be either a function 4424/// designator or an lvalue designating an object. If it is an lvalue, the 4425/// object cannot be declared with storage class register or be a bit field. 4426/// Note: The usual conversions are *not* applied to the operand of the & 4427/// operator (C99 6.3.2.1p[2-4]), and its result is never an lvalue. 4428/// In C++, the operand might be an overloaded function name, in which case 4429/// we allow the '&' but retain the overloaded-function type. 4430QualType Sema::CheckAddressOfOperand(Expr *op, SourceLocation OpLoc) { 4431 // Make sure to ignore parentheses in subsequent checks 4432 op = op->IgnoreParens(); 4433 4434 if (op->isTypeDependent()) 4435 return Context.DependentTy; 4436 4437 if (getLangOptions().C99) { 4438 // Implement C99-only parts of addressof rules. 4439 if (UnaryOperator* uOp = dyn_cast<UnaryOperator>(op)) { 4440 if (uOp->getOpcode() == UnaryOperator::Deref) 4441 // Per C99 6.5.3.2, the address of a deref always returns a valid result 4442 // (assuming the deref expression is valid). 4443 return uOp->getSubExpr()->getType(); 4444 } 4445 // Technically, there should be a check for array subscript 4446 // expressions here, but the result of one is always an lvalue anyway. 4447 } 4448 NamedDecl *dcl = getPrimaryDecl(op); 4449 Expr::isLvalueResult lval = op->isLvalue(Context); 4450 4451 if (lval != Expr::LV_Valid && lval != Expr::LV_IncompleteVoidType) { 4452 // C99 6.5.3.2p1 4453 // The operand must be either an l-value or a function designator 4454 if (!op->getType()->isFunctionType()) { 4455 // FIXME: emit more specific diag... 4456 Diag(OpLoc, diag::err_typecheck_invalid_lvalue_addrof) 4457 << op->getSourceRange(); 4458 return QualType(); 4459 } 4460 } else if (op->getBitField()) { // C99 6.5.3.2p1 4461 // The operand cannot be a bit-field 4462 Diag(OpLoc, diag::err_typecheck_address_of) 4463 << "bit-field" << op->getSourceRange(); 4464 return QualType(); 4465 } else if (isa<ExtVectorElementExpr>(op) || (isa<ArraySubscriptExpr>(op) && 4466 cast<ArraySubscriptExpr>(op)->getBase()->getType()->isVectorType())){ 4467 // The operand cannot be an element of a vector 4468 Diag(OpLoc, diag::err_typecheck_address_of) 4469 << "vector element" << op->getSourceRange(); 4470 return QualType(); 4471 } else if (dcl) { // C99 6.5.3.2p1 4472 // We have an lvalue with a decl. Make sure the decl is not declared 4473 // with the register storage-class specifier. 4474 if (const VarDecl *vd = dyn_cast<VarDecl>(dcl)) { 4475 if (vd->getStorageClass() == VarDecl::Register) { 4476 Diag(OpLoc, diag::err_typecheck_address_of) 4477 << "register variable" << op->getSourceRange(); 4478 return QualType(); 4479 } 4480 } else if (isa<OverloadedFunctionDecl>(dcl)) { 4481 return Context.OverloadTy; 4482 } else if (isa<FieldDecl>(dcl)) { 4483 // Okay: we can take the address of a field. 4484 // Could be a pointer to member, though, if there is an explicit 4485 // scope qualifier for the class. 4486 if (isa<QualifiedDeclRefExpr>(op)) { 4487 DeclContext *Ctx = dcl->getDeclContext(); 4488 if (Ctx && Ctx->isRecord()) 4489 return Context.getMemberPointerType(op->getType(), 4490 Context.getTypeDeclType(cast<RecordDecl>(Ctx)).getTypePtr()); 4491 } 4492 } else if (CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(dcl)) { 4493 // Okay: we can take the address of a function. 4494 // As above. 4495 if (isa<QualifiedDeclRefExpr>(op) && MD->isInstance()) 4496 return Context.getMemberPointerType(op->getType(), 4497 Context.getTypeDeclType(MD->getParent()).getTypePtr()); 4498 } else if (!isa<FunctionDecl>(dcl)) 4499 assert(0 && "Unknown/unexpected decl type"); 4500 } 4501 4502 if (lval == Expr::LV_IncompleteVoidType) { 4503 // Taking the address of a void variable is technically illegal, but we 4504 // allow it in cases which are otherwise valid. 4505 // Example: "extern void x; void* y = &x;". 4506 Diag(OpLoc, diag::ext_typecheck_addrof_void) << op->getSourceRange(); 4507 } 4508 4509 // If the operand has type "type", the result has type "pointer to type". 4510 return Context.getPointerType(op->getType()); 4511} 4512 4513QualType Sema::CheckIndirectionOperand(Expr *Op, SourceLocation OpLoc) { 4514 if (Op->isTypeDependent()) 4515 return Context.DependentTy; 4516 4517 UsualUnaryConversions(Op); 4518 QualType Ty = Op->getType(); 4519 4520 // Note that per both C89 and C99, this is always legal, even if ptype is an 4521 // incomplete type or void. It would be possible to warn about dereferencing 4522 // a void pointer, but it's completely well-defined, and such a warning is 4523 // unlikely to catch any mistakes. 4524 if (const PointerType *PT = Ty->getAsPointerType()) 4525 return PT->getPointeeType(); 4526 4527 Diag(OpLoc, diag::err_typecheck_indirection_requires_pointer) 4528 << Ty << Op->getSourceRange(); 4529 return QualType(); 4530} 4531 4532static inline BinaryOperator::Opcode ConvertTokenKindToBinaryOpcode( 4533 tok::TokenKind Kind) { 4534 BinaryOperator::Opcode Opc; 4535 switch (Kind) { 4536 default: assert(0 && "Unknown binop!"); 4537 case tok::periodstar: Opc = BinaryOperator::PtrMemD; break; 4538 case tok::arrowstar: Opc = BinaryOperator::PtrMemI; break; 4539 case tok::star: Opc = BinaryOperator::Mul; break; 4540 case tok::slash: Opc = BinaryOperator::Div; break; 4541 case tok::percent: Opc = BinaryOperator::Rem; break; 4542 case tok::plus: Opc = BinaryOperator::Add; break; 4543 case tok::minus: Opc = BinaryOperator::Sub; break; 4544 case tok::lessless: Opc = BinaryOperator::Shl; break; 4545 case tok::greatergreater: Opc = BinaryOperator::Shr; break; 4546 case tok::lessequal: Opc = BinaryOperator::LE; break; 4547 case tok::less: Opc = BinaryOperator::LT; break; 4548 case tok::greaterequal: Opc = BinaryOperator::GE; break; 4549 case tok::greater: Opc = BinaryOperator::GT; break; 4550 case tok::exclaimequal: Opc = BinaryOperator::NE; break; 4551 case tok::equalequal: Opc = BinaryOperator::EQ; break; 4552 case tok::amp: Opc = BinaryOperator::And; break; 4553 case tok::caret: Opc = BinaryOperator::Xor; break; 4554 case tok::pipe: Opc = BinaryOperator::Or; break; 4555 case tok::ampamp: Opc = BinaryOperator::LAnd; break; 4556 case tok::pipepipe: Opc = BinaryOperator::LOr; break; 4557 case tok::equal: Opc = BinaryOperator::Assign; break; 4558 case tok::starequal: Opc = BinaryOperator::MulAssign; break; 4559 case tok::slashequal: Opc = BinaryOperator::DivAssign; break; 4560 case tok::percentequal: Opc = BinaryOperator::RemAssign; break; 4561 case tok::plusequal: Opc = BinaryOperator::AddAssign; break; 4562 case tok::minusequal: Opc = BinaryOperator::SubAssign; break; 4563 case tok::lesslessequal: Opc = BinaryOperator::ShlAssign; break; 4564 case tok::greatergreaterequal: Opc = BinaryOperator::ShrAssign; break; 4565 case tok::ampequal: Opc = BinaryOperator::AndAssign; break; 4566 case tok::caretequal: Opc = BinaryOperator::XorAssign; break; 4567 case tok::pipeequal: Opc = BinaryOperator::OrAssign; break; 4568 case tok::comma: Opc = BinaryOperator::Comma; break; 4569 } 4570 return Opc; 4571} 4572 4573static inline UnaryOperator::Opcode ConvertTokenKindToUnaryOpcode( 4574 tok::TokenKind Kind) { 4575 UnaryOperator::Opcode Opc; 4576 switch (Kind) { 4577 default: assert(0 && "Unknown unary op!"); 4578 case tok::plusplus: Opc = UnaryOperator::PreInc; break; 4579 case tok::minusminus: Opc = UnaryOperator::PreDec; break; 4580 case tok::amp: Opc = UnaryOperator::AddrOf; break; 4581 case tok::star: Opc = UnaryOperator::Deref; break; 4582 case tok::plus: Opc = UnaryOperator::Plus; break; 4583 case tok::minus: Opc = UnaryOperator::Minus; break; 4584 case tok::tilde: Opc = UnaryOperator::Not; break; 4585 case tok::exclaim: Opc = UnaryOperator::LNot; break; 4586 case tok::kw___real: Opc = UnaryOperator::Real; break; 4587 case tok::kw___imag: Opc = UnaryOperator::Imag; break; 4588 case tok::kw___extension__: Opc = UnaryOperator::Extension; break; 4589 } 4590 return Opc; 4591} 4592 4593/// CreateBuiltinBinOp - Creates a new built-in binary operation with 4594/// operator @p Opc at location @c TokLoc. This routine only supports 4595/// built-in operations; ActOnBinOp handles overloaded operators. 4596Action::OwningExprResult Sema::CreateBuiltinBinOp(SourceLocation OpLoc, 4597 unsigned Op, 4598 Expr *lhs, Expr *rhs) { 4599 QualType ResultTy; // Result type of the binary operator. 4600 BinaryOperator::Opcode Opc = (BinaryOperator::Opcode)Op; 4601 // The following two variables are used for compound assignment operators 4602 QualType CompLHSTy; // Type of LHS after promotions for computation 4603 QualType CompResultTy; // Type of computation result 4604 4605 switch (Opc) { 4606 case BinaryOperator::Assign: 4607 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, QualType()); 4608 break; 4609 case BinaryOperator::PtrMemD: 4610 case BinaryOperator::PtrMemI: 4611 ResultTy = CheckPointerToMemberOperands(lhs, rhs, OpLoc, 4612 Opc == BinaryOperator::PtrMemI); 4613 break; 4614 case BinaryOperator::Mul: 4615 case BinaryOperator::Div: 4616 ResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc); 4617 break; 4618 case BinaryOperator::Rem: 4619 ResultTy = CheckRemainderOperands(lhs, rhs, OpLoc); 4620 break; 4621 case BinaryOperator::Add: 4622 ResultTy = CheckAdditionOperands(lhs, rhs, OpLoc); 4623 break; 4624 case BinaryOperator::Sub: 4625 ResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc); 4626 break; 4627 case BinaryOperator::Shl: 4628 case BinaryOperator::Shr: 4629 ResultTy = CheckShiftOperands(lhs, rhs, OpLoc); 4630 break; 4631 case BinaryOperator::LE: 4632 case BinaryOperator::LT: 4633 case BinaryOperator::GE: 4634 case BinaryOperator::GT: 4635 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, true); 4636 break; 4637 case BinaryOperator::EQ: 4638 case BinaryOperator::NE: 4639 ResultTy = CheckCompareOperands(lhs, rhs, OpLoc, Opc, false); 4640 break; 4641 case BinaryOperator::And: 4642 case BinaryOperator::Xor: 4643 case BinaryOperator::Or: 4644 ResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc); 4645 break; 4646 case BinaryOperator::LAnd: 4647 case BinaryOperator::LOr: 4648 ResultTy = CheckLogicalOperands(lhs, rhs, OpLoc); 4649 break; 4650 case BinaryOperator::MulAssign: 4651 case BinaryOperator::DivAssign: 4652 CompResultTy = CheckMultiplyDivideOperands(lhs, rhs, OpLoc, true); 4653 CompLHSTy = CompResultTy; 4654 if (!CompResultTy.isNull()) 4655 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy); 4656 break; 4657 case BinaryOperator::RemAssign: 4658 CompResultTy = CheckRemainderOperands(lhs, rhs, OpLoc, true); 4659 CompLHSTy = CompResultTy; 4660 if (!CompResultTy.isNull()) 4661 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy); 4662 break; 4663 case BinaryOperator::AddAssign: 4664 CompResultTy = CheckAdditionOperands(lhs, rhs, OpLoc, &CompLHSTy); 4665 if (!CompResultTy.isNull()) 4666 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy); 4667 break; 4668 case BinaryOperator::SubAssign: 4669 CompResultTy = CheckSubtractionOperands(lhs, rhs, OpLoc, &CompLHSTy); 4670 if (!CompResultTy.isNull()) 4671 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy); 4672 break; 4673 case BinaryOperator::ShlAssign: 4674 case BinaryOperator::ShrAssign: 4675 CompResultTy = CheckShiftOperands(lhs, rhs, OpLoc, true); 4676 CompLHSTy = CompResultTy; 4677 if (!CompResultTy.isNull()) 4678 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy); 4679 break; 4680 case BinaryOperator::AndAssign: 4681 case BinaryOperator::XorAssign: 4682 case BinaryOperator::OrAssign: 4683 CompResultTy = CheckBitwiseOperands(lhs, rhs, OpLoc, true); 4684 CompLHSTy = CompResultTy; 4685 if (!CompResultTy.isNull()) 4686 ResultTy = CheckAssignmentOperands(lhs, rhs, OpLoc, CompResultTy); 4687 break; 4688 case BinaryOperator::Comma: 4689 ResultTy = CheckCommaOperands(lhs, rhs, OpLoc); 4690 break; 4691 } 4692 if (ResultTy.isNull()) 4693 return ExprError(); 4694 if (CompResultTy.isNull()) 4695 return Owned(new (Context) BinaryOperator(lhs, rhs, Opc, ResultTy, OpLoc)); 4696 else 4697 return Owned(new (Context) CompoundAssignOperator(lhs, rhs, Opc, ResultTy, 4698 CompLHSTy, CompResultTy, 4699 OpLoc)); 4700} 4701 4702// Binary Operators. 'Tok' is the token for the operator. 4703Action::OwningExprResult Sema::ActOnBinOp(Scope *S, SourceLocation TokLoc, 4704 tok::TokenKind Kind, 4705 ExprArg LHS, ExprArg RHS) { 4706 BinaryOperator::Opcode Opc = ConvertTokenKindToBinaryOpcode(Kind); 4707 Expr *lhs = LHS.takeAs<Expr>(), *rhs = RHS.takeAs<Expr>(); 4708 4709 assert((lhs != 0) && "ActOnBinOp(): missing left expression"); 4710 assert((rhs != 0) && "ActOnBinOp(): missing right expression"); 4711 4712 if (getLangOptions().CPlusPlus && 4713 (lhs->getType()->isOverloadableType() || 4714 rhs->getType()->isOverloadableType())) { 4715 // Find all of the overloaded operators visible from this 4716 // point. We perform both an operator-name lookup from the local 4717 // scope and an argument-dependent lookup based on the types of 4718 // the arguments. 4719 FunctionSet Functions; 4720 OverloadedOperatorKind OverOp = BinaryOperator::getOverloadedOperator(Opc); 4721 if (OverOp != OO_None) { 4722 LookupOverloadedOperatorName(OverOp, S, lhs->getType(), rhs->getType(), 4723 Functions); 4724 Expr *Args[2] = { lhs, rhs }; 4725 DeclarationName OpName 4726 = Context.DeclarationNames.getCXXOperatorName(OverOp); 4727 ArgumentDependentLookup(OpName, Args, 2, Functions); 4728 } 4729 4730 // Build the (potentially-overloaded, potentially-dependent) 4731 // binary operation. 4732 return CreateOverloadedBinOp(TokLoc, Opc, Functions, lhs, rhs); 4733 } 4734 4735 // Build a built-in binary operation. 4736 return CreateBuiltinBinOp(TokLoc, Opc, lhs, rhs); 4737} 4738 4739Action::OwningExprResult Sema::CreateBuiltinUnaryOp(SourceLocation OpLoc, 4740 unsigned OpcIn, 4741 ExprArg InputArg) { 4742 UnaryOperator::Opcode Opc = static_cast<UnaryOperator::Opcode>(OpcIn); 4743 4744 // FIXME: Input is modified below, but InputArg is not updated appropriately. 4745 Expr *Input = (Expr *)InputArg.get(); 4746 QualType resultType; 4747 switch (Opc) { 4748 case UnaryOperator::PostInc: 4749 case UnaryOperator::PostDec: 4750 case UnaryOperator::OffsetOf: 4751 assert(false && "Invalid unary operator"); 4752 break; 4753 4754 case UnaryOperator::PreInc: 4755 case UnaryOperator::PreDec: 4756 resultType = CheckIncrementDecrementOperand(Input, OpLoc, 4757 Opc == UnaryOperator::PreInc); 4758 break; 4759 case UnaryOperator::AddrOf: 4760 resultType = CheckAddressOfOperand(Input, OpLoc); 4761 break; 4762 case UnaryOperator::Deref: 4763 DefaultFunctionArrayConversion(Input); 4764 resultType = CheckIndirectionOperand(Input, OpLoc); 4765 break; 4766 case UnaryOperator::Plus: 4767 case UnaryOperator::Minus: 4768 UsualUnaryConversions(Input); 4769 resultType = Input->getType(); 4770 if (resultType->isDependentType()) 4771 break; 4772 if (resultType->isArithmeticType()) // C99 6.5.3.3p1 4773 break; 4774 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6-7 4775 resultType->isEnumeralType()) 4776 break; 4777 else if (getLangOptions().CPlusPlus && // C++ [expr.unary.op]p6 4778 Opc == UnaryOperator::Plus && 4779 resultType->isPointerType()) 4780 break; 4781 4782 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 4783 << resultType << Input->getSourceRange()); 4784 case UnaryOperator::Not: // bitwise complement 4785 UsualUnaryConversions(Input); 4786 resultType = Input->getType(); 4787 if (resultType->isDependentType()) 4788 break; 4789 // C99 6.5.3.3p1. We allow complex int and float as a GCC extension. 4790 if (resultType->isComplexType() || resultType->isComplexIntegerType()) 4791 // C99 does not support '~' for complex conjugation. 4792 Diag(OpLoc, diag::ext_integer_complement_complex) 4793 << resultType << Input->getSourceRange(); 4794 else if (!resultType->isIntegerType()) 4795 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 4796 << resultType << Input->getSourceRange()); 4797 break; 4798 case UnaryOperator::LNot: // logical negation 4799 // Unlike +/-/~, integer promotions aren't done here (C99 6.5.3.3p5). 4800 DefaultFunctionArrayConversion(Input); 4801 resultType = Input->getType(); 4802 if (resultType->isDependentType()) 4803 break; 4804 if (!resultType->isScalarType()) // C99 6.5.3.3p1 4805 return ExprError(Diag(OpLoc, diag::err_typecheck_unary_expr) 4806 << resultType << Input->getSourceRange()); 4807 // LNot always has type int. C99 6.5.3.3p5. 4808 // In C++, it's bool. C++ 5.3.1p8 4809 resultType = getLangOptions().CPlusPlus ? Context.BoolTy : Context.IntTy; 4810 break; 4811 case UnaryOperator::Real: 4812 case UnaryOperator::Imag: 4813 resultType = CheckRealImagOperand(Input, OpLoc, Opc == UnaryOperator::Real); 4814 break; 4815 case UnaryOperator::Extension: 4816 resultType = Input->getType(); 4817 break; 4818 } 4819 if (resultType.isNull()) 4820 return ExprError(); 4821 4822 InputArg.release(); 4823 return Owned(new (Context) UnaryOperator(Input, Opc, resultType, OpLoc)); 4824} 4825 4826// Unary Operators. 'Tok' is the token for the operator. 4827Action::OwningExprResult Sema::ActOnUnaryOp(Scope *S, SourceLocation OpLoc, 4828 tok::TokenKind Op, ExprArg input) { 4829 Expr *Input = (Expr*)input.get(); 4830 UnaryOperator::Opcode Opc = ConvertTokenKindToUnaryOpcode(Op); 4831 4832 if (getLangOptions().CPlusPlus && Input->getType()->isOverloadableType()) { 4833 // Find all of the overloaded operators visible from this 4834 // point. We perform both an operator-name lookup from the local 4835 // scope and an argument-dependent lookup based on the types of 4836 // the arguments. 4837 FunctionSet Functions; 4838 OverloadedOperatorKind OverOp = UnaryOperator::getOverloadedOperator(Opc); 4839 if (OverOp != OO_None) { 4840 LookupOverloadedOperatorName(OverOp, S, Input->getType(), QualType(), 4841 Functions); 4842 DeclarationName OpName 4843 = Context.DeclarationNames.getCXXOperatorName(OverOp); 4844 ArgumentDependentLookup(OpName, &Input, 1, Functions); 4845 } 4846 4847 return CreateOverloadedUnaryOp(OpLoc, Opc, Functions, move(input)); 4848 } 4849 4850 return CreateBuiltinUnaryOp(OpLoc, Opc, move(input)); 4851} 4852 4853/// ActOnAddrLabel - Parse the GNU address of label extension: "&&foo". 4854Sema::OwningExprResult Sema::ActOnAddrLabel(SourceLocation OpLoc, 4855 SourceLocation LabLoc, 4856 IdentifierInfo *LabelII) { 4857 // Look up the record for this label identifier. 4858 LabelStmt *&LabelDecl = getLabelMap()[LabelII]; 4859 4860 // If we haven't seen this label yet, create a forward reference. It 4861 // will be validated and/or cleaned up in ActOnFinishFunctionBody. 4862 if (LabelDecl == 0) 4863 LabelDecl = new (Context) LabelStmt(LabLoc, LabelII, 0); 4864 4865 // Create the AST node. The address of a label always has type 'void*'. 4866 return Owned(new (Context) AddrLabelExpr(OpLoc, LabLoc, LabelDecl, 4867 Context.getPointerType(Context.VoidTy))); 4868} 4869 4870Sema::OwningExprResult 4871Sema::ActOnStmtExpr(SourceLocation LPLoc, StmtArg substmt, 4872 SourceLocation RPLoc) { // "({..})" 4873 Stmt *SubStmt = static_cast<Stmt*>(substmt.get()); 4874 assert(SubStmt && isa<CompoundStmt>(SubStmt) && "Invalid action invocation!"); 4875 CompoundStmt *Compound = cast<CompoundStmt>(SubStmt); 4876 4877 bool isFileScope = getCurFunctionOrMethodDecl() == 0; 4878 if (isFileScope) 4879 return ExprError(Diag(LPLoc, diag::err_stmtexpr_file_scope)); 4880 4881 // FIXME: there are a variety of strange constraints to enforce here, for 4882 // example, it is not possible to goto into a stmt expression apparently. 4883 // More semantic analysis is needed. 4884 4885 // If there are sub stmts in the compound stmt, take the type of the last one 4886 // as the type of the stmtexpr. 4887 QualType Ty = Context.VoidTy; 4888 4889 if (!Compound->body_empty()) { 4890 Stmt *LastStmt = Compound->body_back(); 4891 // If LastStmt is a label, skip down through into the body. 4892 while (LabelStmt *Label = dyn_cast<LabelStmt>(LastStmt)) 4893 LastStmt = Label->getSubStmt(); 4894 4895 if (Expr *LastExpr = dyn_cast<Expr>(LastStmt)) 4896 Ty = LastExpr->getType(); 4897 } 4898 4899 // FIXME: Check that expression type is complete/non-abstract; statement 4900 // expressions are not lvalues. 4901 4902 substmt.release(); 4903 return Owned(new (Context) StmtExpr(Compound, Ty, LPLoc, RPLoc)); 4904} 4905 4906Sema::OwningExprResult Sema::ActOnBuiltinOffsetOf(Scope *S, 4907 SourceLocation BuiltinLoc, 4908 SourceLocation TypeLoc, 4909 TypeTy *argty, 4910 OffsetOfComponent *CompPtr, 4911 unsigned NumComponents, 4912 SourceLocation RPLoc) { 4913 // FIXME: This function leaks all expressions in the offset components on 4914 // error. 4915 QualType ArgTy = QualType::getFromOpaquePtr(argty); 4916 assert(!ArgTy.isNull() && "Missing type argument!"); 4917 4918 bool Dependent = ArgTy->isDependentType(); 4919 4920 // We must have at least one component that refers to the type, and the first 4921 // one is known to be a field designator. Verify that the ArgTy represents 4922 // a struct/union/class. 4923 if (!Dependent && !ArgTy->isRecordType()) 4924 return ExprError(Diag(TypeLoc, diag::err_offsetof_record_type) << ArgTy); 4925 4926 // FIXME: Type must be complete per C99 7.17p3 because a declaring a variable 4927 // with an incomplete type would be illegal. 4928 4929 // Otherwise, create a null pointer as the base, and iteratively process 4930 // the offsetof designators. 4931 QualType ArgTyPtr = Context.getPointerType(ArgTy); 4932 Expr* Res = new (Context) ImplicitValueInitExpr(ArgTyPtr); 4933 Res = new (Context) UnaryOperator(Res, UnaryOperator::Deref, 4934 ArgTy, SourceLocation()); 4935 4936 // offsetof with non-identifier designators (e.g. "offsetof(x, a.b[c])") are a 4937 // GCC extension, diagnose them. 4938 // FIXME: This diagnostic isn't actually visible because the location is in 4939 // a system header! 4940 if (NumComponents != 1) 4941 Diag(BuiltinLoc, diag::ext_offsetof_extended_field_designator) 4942 << SourceRange(CompPtr[1].LocStart, CompPtr[NumComponents-1].LocEnd); 4943 4944 if (!Dependent) { 4945 bool DidWarnAboutNonPOD = false; 4946 4947 // FIXME: Dependent case loses a lot of information here. And probably 4948 // leaks like a sieve. 4949 for (unsigned i = 0; i != NumComponents; ++i) { 4950 const OffsetOfComponent &OC = CompPtr[i]; 4951 if (OC.isBrackets) { 4952 // Offset of an array sub-field. TODO: Should we allow vector elements? 4953 const ArrayType *AT = Context.getAsArrayType(Res->getType()); 4954 if (!AT) { 4955 Res->Destroy(Context); 4956 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_array_type) 4957 << Res->getType()); 4958 } 4959 4960 // FIXME: C++: Verify that operator[] isn't overloaded. 4961 4962 // Promote the array so it looks more like a normal array subscript 4963 // expression. 4964 DefaultFunctionArrayConversion(Res); 4965 4966 // C99 6.5.2.1p1 4967 Expr *Idx = static_cast<Expr*>(OC.U.E); 4968 // FIXME: Leaks Res 4969 if (!Idx->isTypeDependent() && !Idx->getType()->isIntegerType()) 4970 return ExprError(Diag(Idx->getLocStart(), 4971 diag::err_typecheck_subscript_not_integer) 4972 << Idx->getSourceRange()); 4973 4974 Res = new (Context) ArraySubscriptExpr(Res, Idx, AT->getElementType(), 4975 OC.LocEnd); 4976 continue; 4977 } 4978 4979 const RecordType *RC = Res->getType()->getAsRecordType(); 4980 if (!RC) { 4981 Res->Destroy(Context); 4982 return ExprError(Diag(OC.LocEnd, diag::err_offsetof_record_type) 4983 << Res->getType()); 4984 } 4985 4986 // Get the decl corresponding to this. 4987 RecordDecl *RD = RC->getDecl(); 4988 if (CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(RD)) { 4989 if (!CRD->isPOD() && !DidWarnAboutNonPOD) { 4990 ExprError(Diag(BuiltinLoc, diag::warn_offsetof_non_pod_type) 4991 << SourceRange(CompPtr[0].LocStart, OC.LocEnd) 4992 << Res->getType()); 4993 DidWarnAboutNonPOD = true; 4994 } 4995 } 4996 4997 FieldDecl *MemberDecl 4998 = dyn_cast_or_null<FieldDecl>(LookupQualifiedName(RD, OC.U.IdentInfo, 4999 LookupMemberName) 5000 .getAsDecl()); 5001 // FIXME: Leaks Res 5002 if (!MemberDecl) 5003 return ExprError(Diag(BuiltinLoc, diag::err_typecheck_no_member) 5004 << OC.U.IdentInfo << SourceRange(OC.LocStart, OC.LocEnd)); 5005 5006 // FIXME: C++: Verify that MemberDecl isn't a static field. 5007 // FIXME: Verify that MemberDecl isn't a bitfield. 5008 if (cast<RecordDecl>(MemberDecl->getDeclContext())->isAnonymousStructOrUnion()) { 5009 Res = BuildAnonymousStructUnionMemberReference( 5010 SourceLocation(), MemberDecl, Res, SourceLocation()).takeAs<Expr>(); 5011 } else { 5012 // MemberDecl->getType() doesn't get the right qualifiers, but it 5013 // doesn't matter here. 5014 Res = new (Context) MemberExpr(Res, false, MemberDecl, OC.LocEnd, 5015 MemberDecl->getType().getNonReferenceType()); 5016 } 5017 } 5018 } 5019 5020 return Owned(new (Context) UnaryOperator(Res, UnaryOperator::OffsetOf, 5021 Context.getSizeType(), BuiltinLoc)); 5022} 5023 5024 5025Sema::OwningExprResult Sema::ActOnTypesCompatibleExpr(SourceLocation BuiltinLoc, 5026 TypeTy *arg1,TypeTy *arg2, 5027 SourceLocation RPLoc) { 5028 QualType argT1 = QualType::getFromOpaquePtr(arg1); 5029 QualType argT2 = QualType::getFromOpaquePtr(arg2); 5030 5031 assert((!argT1.isNull() && !argT2.isNull()) && "Missing type argument(s)"); 5032 5033 if (getLangOptions().CPlusPlus) { 5034 Diag(BuiltinLoc, diag::err_types_compatible_p_in_cplusplus) 5035 << SourceRange(BuiltinLoc, RPLoc); 5036 return ExprError(); 5037 } 5038 5039 return Owned(new (Context) TypesCompatibleExpr(Context.IntTy, BuiltinLoc, 5040 argT1, argT2, RPLoc)); 5041} 5042 5043Sema::OwningExprResult Sema::ActOnChooseExpr(SourceLocation BuiltinLoc, 5044 ExprArg cond, 5045 ExprArg expr1, ExprArg expr2, 5046 SourceLocation RPLoc) { 5047 Expr *CondExpr = static_cast<Expr*>(cond.get()); 5048 Expr *LHSExpr = static_cast<Expr*>(expr1.get()); 5049 Expr *RHSExpr = static_cast<Expr*>(expr2.get()); 5050 5051 assert((CondExpr && LHSExpr && RHSExpr) && "Missing type argument(s)"); 5052 5053 QualType resType; 5054 if (CondExpr->isTypeDependent() || CondExpr->isValueDependent()) { 5055 resType = Context.DependentTy; 5056 } else { 5057 // The conditional expression is required to be a constant expression. 5058 llvm::APSInt condEval(32); 5059 SourceLocation ExpLoc; 5060 if (!CondExpr->isIntegerConstantExpr(condEval, Context, &ExpLoc)) 5061 return ExprError(Diag(ExpLoc, 5062 diag::err_typecheck_choose_expr_requires_constant) 5063 << CondExpr->getSourceRange()); 5064 5065 // If the condition is > zero, then the AST type is the same as the LSHExpr. 5066 resType = condEval.getZExtValue() ? LHSExpr->getType() : RHSExpr->getType(); 5067 } 5068 5069 cond.release(); expr1.release(); expr2.release(); 5070 return Owned(new (Context) ChooseExpr(BuiltinLoc, CondExpr, LHSExpr, RHSExpr, 5071 resType, RPLoc)); 5072} 5073 5074//===----------------------------------------------------------------------===// 5075// Clang Extensions. 5076//===----------------------------------------------------------------------===// 5077 5078/// ActOnBlockStart - This callback is invoked when a block literal is started. 5079void Sema::ActOnBlockStart(SourceLocation CaretLoc, Scope *BlockScope) { 5080 // Analyze block parameters. 5081 BlockSemaInfo *BSI = new BlockSemaInfo(); 5082 5083 // Add BSI to CurBlock. 5084 BSI->PrevBlockInfo = CurBlock; 5085 CurBlock = BSI; 5086 5087 BSI->ReturnType = 0; 5088 BSI->TheScope = BlockScope; 5089 BSI->hasBlockDeclRefExprs = false; 5090 BSI->SavedFunctionNeedsScopeChecking = CurFunctionNeedsScopeChecking; 5091 CurFunctionNeedsScopeChecking = false; 5092 5093 BSI->TheDecl = BlockDecl::Create(Context, CurContext, CaretLoc); 5094 PushDeclContext(BlockScope, BSI->TheDecl); 5095} 5096 5097void Sema::ActOnBlockArguments(Declarator &ParamInfo, Scope *CurScope) { 5098 assert(ParamInfo.getIdentifier()==0 && "block-id should have no identifier!"); 5099 5100 if (ParamInfo.getNumTypeObjects() == 0 5101 || ParamInfo.getTypeObject(0).Kind != DeclaratorChunk::Function) { 5102 ProcessDeclAttributes(CurBlock->TheDecl, ParamInfo); 5103 QualType T = GetTypeForDeclarator(ParamInfo, CurScope); 5104 5105 if (T->isArrayType()) { 5106 Diag(ParamInfo.getSourceRange().getBegin(), 5107 diag::err_block_returns_array); 5108 return; 5109 } 5110 5111 // The parameter list is optional, if there was none, assume (). 5112 if (!T->isFunctionType()) 5113 T = Context.getFunctionType(T, NULL, 0, 0, 0); 5114 5115 CurBlock->hasPrototype = true; 5116 CurBlock->isVariadic = false; 5117 // Check for a valid sentinel attribute on this block. 5118 if (CurBlock->TheDecl->getAttr<SentinelAttr>()) { 5119 Diag(ParamInfo.getAttributes()->getLoc(), 5120 diag::warn_attribute_sentinel_not_variadic) << 1; 5121 // FIXME: remove the attribute. 5122 } 5123 QualType RetTy = T.getTypePtr()->getAsFunctionType()->getResultType(); 5124 5125 // Do not allow returning a objc interface by-value. 5126 if (RetTy->isObjCInterfaceType()) { 5127 Diag(ParamInfo.getSourceRange().getBegin(), 5128 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy; 5129 return; 5130 } 5131 return; 5132 } 5133 5134 // Analyze arguments to block. 5135 assert(ParamInfo.getTypeObject(0).Kind == DeclaratorChunk::Function && 5136 "Not a function declarator!"); 5137 DeclaratorChunk::FunctionTypeInfo &FTI = ParamInfo.getTypeObject(0).Fun; 5138 5139 CurBlock->hasPrototype = FTI.hasPrototype; 5140 CurBlock->isVariadic = true; 5141 5142 // Check for C99 6.7.5.3p10 - foo(void) is a non-varargs function that takes 5143 // no arguments, not a function that takes a single void argument. 5144 if (FTI.hasPrototype && 5145 FTI.NumArgs == 1 && !FTI.isVariadic && FTI.ArgInfo[0].Ident == 0 && 5146 (!FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType().getCVRQualifiers()&& 5147 FTI.ArgInfo[0].Param.getAs<ParmVarDecl>()->getType()->isVoidType())) { 5148 // empty arg list, don't push any params. 5149 CurBlock->isVariadic = false; 5150 } else if (FTI.hasPrototype) { 5151 for (unsigned i = 0, e = FTI.NumArgs; i != e; ++i) 5152 CurBlock->Params.push_back(FTI.ArgInfo[i].Param.getAs<ParmVarDecl>()); 5153 CurBlock->isVariadic = FTI.isVariadic; 5154 } 5155 CurBlock->TheDecl->setParams(Context, CurBlock->Params.data(), 5156 CurBlock->Params.size()); 5157 CurBlock->TheDecl->setIsVariadic(CurBlock->isVariadic); 5158 ProcessDeclAttributes(CurBlock->TheDecl, ParamInfo); 5159 for (BlockDecl::param_iterator AI = CurBlock->TheDecl->param_begin(), 5160 E = CurBlock->TheDecl->param_end(); AI != E; ++AI) 5161 // If this has an identifier, add it to the scope stack. 5162 if ((*AI)->getIdentifier()) 5163 PushOnScopeChains(*AI, CurBlock->TheScope); 5164 5165 // Check for a valid sentinel attribute on this block. 5166 if (!CurBlock->isVariadic && CurBlock->TheDecl->getAttr<SentinelAttr>()) { 5167 Diag(ParamInfo.getAttributes()->getLoc(), 5168 diag::warn_attribute_sentinel_not_variadic) << 1; 5169 // FIXME: remove the attribute. 5170 } 5171 5172 // Analyze the return type. 5173 QualType T = GetTypeForDeclarator(ParamInfo, CurScope); 5174 QualType RetTy = T->getAsFunctionType()->getResultType(); 5175 5176 // Do not allow returning a objc interface by-value. 5177 if (RetTy->isObjCInterfaceType()) { 5178 Diag(ParamInfo.getSourceRange().getBegin(), 5179 diag::err_object_cannot_be_passed_returned_by_value) << 0 << RetTy; 5180 } else if (!RetTy->isDependentType()) 5181 CurBlock->ReturnType = RetTy.getTypePtr(); 5182} 5183 5184/// ActOnBlockError - If there is an error parsing a block, this callback 5185/// is invoked to pop the information about the block from the action impl. 5186void Sema::ActOnBlockError(SourceLocation CaretLoc, Scope *CurScope) { 5187 // Ensure that CurBlock is deleted. 5188 llvm::OwningPtr<BlockSemaInfo> CC(CurBlock); 5189 5190 CurFunctionNeedsScopeChecking = CurBlock->SavedFunctionNeedsScopeChecking; 5191 5192 // Pop off CurBlock, handle nested blocks. 5193 PopDeclContext(); 5194 CurBlock = CurBlock->PrevBlockInfo; 5195 // FIXME: Delete the ParmVarDecl objects as well??? 5196} 5197 5198/// ActOnBlockStmtExpr - This is called when the body of a block statement 5199/// literal was successfully completed. ^(int x){...} 5200Sema::OwningExprResult Sema::ActOnBlockStmtExpr(SourceLocation CaretLoc, 5201 StmtArg body, Scope *CurScope) { 5202 // If blocks are disabled, emit an error. 5203 if (!LangOpts.Blocks) 5204 Diag(CaretLoc, diag::err_blocks_disable); 5205 5206 // Ensure that CurBlock is deleted. 5207 llvm::OwningPtr<BlockSemaInfo> BSI(CurBlock); 5208 5209 PopDeclContext(); 5210 5211 // Pop off CurBlock, handle nested blocks. 5212 CurBlock = CurBlock->PrevBlockInfo; 5213 5214 QualType RetTy = Context.VoidTy; 5215 if (BSI->ReturnType) 5216 RetTy = QualType(BSI->ReturnType, 0); 5217 5218 llvm::SmallVector<QualType, 8> ArgTypes; 5219 for (unsigned i = 0, e = BSI->Params.size(); i != e; ++i) 5220 ArgTypes.push_back(BSI->Params[i]->getType()); 5221 5222 QualType BlockTy; 5223 if (!BSI->hasPrototype) 5224 BlockTy = Context.getFunctionNoProtoType(RetTy); 5225 else 5226 BlockTy = Context.getFunctionType(RetTy, ArgTypes.data(), ArgTypes.size(), 5227 BSI->isVariadic, 0); 5228 5229 // FIXME: Check that return/parameter types are complete/non-abstract 5230 5231 BlockTy = Context.getBlockPointerType(BlockTy); 5232 5233 // If needed, diagnose invalid gotos and switches in the block. 5234 if (CurFunctionNeedsScopeChecking) 5235 DiagnoseInvalidJumps(static_cast<CompoundStmt*>(body.get())); 5236 CurFunctionNeedsScopeChecking = BSI->SavedFunctionNeedsScopeChecking; 5237 5238 BSI->TheDecl->setBody(body.takeAs<CompoundStmt>()); 5239 return Owned(new (Context) BlockExpr(BSI->TheDecl, BlockTy, 5240 BSI->hasBlockDeclRefExprs)); 5241} 5242 5243Sema::OwningExprResult Sema::ActOnVAArg(SourceLocation BuiltinLoc, 5244 ExprArg expr, TypeTy *type, 5245 SourceLocation RPLoc) { 5246 QualType T = QualType::getFromOpaquePtr(type); 5247 Expr *E = static_cast<Expr*>(expr.get()); 5248 Expr *OrigExpr = E; 5249 5250 InitBuiltinVaListType(); 5251 5252 // Get the va_list type 5253 QualType VaListType = Context.getBuiltinVaListType(); 5254 if (VaListType->isArrayType()) { 5255 // Deal with implicit array decay; for example, on x86-64, 5256 // va_list is an array, but it's supposed to decay to 5257 // a pointer for va_arg. 5258 VaListType = Context.getArrayDecayedType(VaListType); 5259 // Make sure the input expression also decays appropriately. 5260 UsualUnaryConversions(E); 5261 } else { 5262 // Otherwise, the va_list argument must be an l-value because 5263 // it is modified by va_arg. 5264 if (!E->isTypeDependent() && 5265 CheckForModifiableLvalue(E, BuiltinLoc, *this)) 5266 return ExprError(); 5267 } 5268 5269 if (!E->isTypeDependent() && 5270 !Context.hasSameType(VaListType, E->getType())) { 5271 return ExprError(Diag(E->getLocStart(), 5272 diag::err_first_argument_to_va_arg_not_of_type_va_list) 5273 << OrigExpr->getType() << E->getSourceRange()); 5274 } 5275 5276 // FIXME: Check that type is complete/non-abstract 5277 // FIXME: Warn if a non-POD type is passed in. 5278 5279 expr.release(); 5280 return Owned(new (Context) VAArgExpr(BuiltinLoc, E, T.getNonReferenceType(), 5281 RPLoc)); 5282} 5283 5284Sema::OwningExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) { 5285 // The type of __null will be int or long, depending on the size of 5286 // pointers on the target. 5287 QualType Ty; 5288 if (Context.Target.getPointerWidth(0) == Context.Target.getIntWidth()) 5289 Ty = Context.IntTy; 5290 else 5291 Ty = Context.LongTy; 5292 5293 return Owned(new (Context) GNUNullExpr(Ty, TokenLoc)); 5294} 5295 5296bool Sema::DiagnoseAssignmentResult(AssignConvertType ConvTy, 5297 SourceLocation Loc, 5298 QualType DstType, QualType SrcType, 5299 Expr *SrcExpr, const char *Flavor) { 5300 // Decode the result (notice that AST's are still created for extensions). 5301 bool isInvalid = false; 5302 unsigned DiagKind; 5303 switch (ConvTy) { 5304 default: assert(0 && "Unknown conversion type"); 5305 case Compatible: return false; 5306 case PointerToInt: 5307 DiagKind = diag::ext_typecheck_convert_pointer_int; 5308 break; 5309 case IntToPointer: 5310 DiagKind = diag::ext_typecheck_convert_int_pointer; 5311 break; 5312 case IncompatiblePointer: 5313 DiagKind = diag::ext_typecheck_convert_incompatible_pointer; 5314 break; 5315 case IncompatiblePointerSign: 5316 DiagKind = diag::ext_typecheck_convert_incompatible_pointer_sign; 5317 break; 5318 case FunctionVoidPointer: 5319 DiagKind = diag::ext_typecheck_convert_pointer_void_func; 5320 break; 5321 case CompatiblePointerDiscardsQualifiers: 5322 // If the qualifiers lost were because we were applying the 5323 // (deprecated) C++ conversion from a string literal to a char* 5324 // (or wchar_t*), then there was no error (C++ 4.2p2). FIXME: 5325 // Ideally, this check would be performed in 5326 // CheckPointerTypesForAssignment. However, that would require a 5327 // bit of refactoring (so that the second argument is an 5328 // expression, rather than a type), which should be done as part 5329 // of a larger effort to fix CheckPointerTypesForAssignment for 5330 // C++ semantics. 5331 if (getLangOptions().CPlusPlus && 5332 IsStringLiteralToNonConstPointerConversion(SrcExpr, DstType)) 5333 return false; 5334 DiagKind = diag::ext_typecheck_convert_discards_qualifiers; 5335 break; 5336 case IntToBlockPointer: 5337 DiagKind = diag::err_int_to_block_pointer; 5338 break; 5339 case IncompatibleBlockPointer: 5340 DiagKind = diag::err_typecheck_convert_incompatible_block_pointer; 5341 break; 5342 case IncompatibleObjCQualifiedId: 5343 // FIXME: Diagnose the problem in ObjCQualifiedIdTypesAreCompatible, since 5344 // it can give a more specific diagnostic. 5345 DiagKind = diag::warn_incompatible_qualified_id; 5346 break; 5347 case IncompatibleVectors: 5348 DiagKind = diag::warn_incompatible_vectors; 5349 break; 5350 case Incompatible: 5351 DiagKind = diag::err_typecheck_convert_incompatible; 5352 isInvalid = true; 5353 break; 5354 } 5355 5356 Diag(Loc, DiagKind) << DstType << SrcType << Flavor 5357 << SrcExpr->getSourceRange(); 5358 return isInvalid; 5359} 5360 5361bool Sema::VerifyIntegerConstantExpression(const Expr *E, llvm::APSInt *Result){ 5362 llvm::APSInt ICEResult; 5363 if (E->isIntegerConstantExpr(ICEResult, Context)) { 5364 if (Result) 5365 *Result = ICEResult; 5366 return false; 5367 } 5368 5369 Expr::EvalResult EvalResult; 5370 5371 if (!E->Evaluate(EvalResult, Context) || !EvalResult.Val.isInt() || 5372 EvalResult.HasSideEffects) { 5373 Diag(E->getExprLoc(), diag::err_expr_not_ice) << E->getSourceRange(); 5374 5375 if (EvalResult.Diag) { 5376 // We only show the note if it's not the usual "invalid subexpression" 5377 // or if it's actually in a subexpression. 5378 if (EvalResult.Diag != diag::note_invalid_subexpr_in_ice || 5379 E->IgnoreParens() != EvalResult.DiagExpr->IgnoreParens()) 5380 Diag(EvalResult.DiagLoc, EvalResult.Diag); 5381 } 5382 5383 return true; 5384 } 5385 5386 Diag(E->getExprLoc(), diag::ext_expr_not_ice) << 5387 E->getSourceRange(); 5388 5389 if (EvalResult.Diag && 5390 Diags.getDiagnosticLevel(diag::ext_expr_not_ice) != Diagnostic::Ignored) 5391 Diag(EvalResult.DiagLoc, EvalResult.Diag); 5392 5393 if (Result) 5394 *Result = EvalResult.Val.getInt(); 5395 return false; 5396} 5397