Sema.cpp revision 10324db994455a9a1520be6cfe5bb29685cde141
1//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===// 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 the actions class which performs semantic analysis and 11// builds an AST out of a parse stream. 12// 13//===----------------------------------------------------------------------===// 14 15#include "Sema.h" 16#include "llvm/ADT/DenseMap.h" 17#include "llvm/ADT/APFloat.h" 18#include "clang/AST/ASTConsumer.h" 19#include "clang/AST/ASTContext.h" 20#include "clang/AST/DeclObjC.h" 21#include "clang/AST/Expr.h" 22#include "clang/Lex/Preprocessor.h" 23#include "clang/Basic/PartialDiagnostic.h" 24#include "clang/Basic/TargetInfo.h" 25using namespace clang; 26 27/// Determines whether we should have an a.k.a. clause when 28/// pretty-printing a type. There are three main criteria: 29/// 30/// 1) Some types provide very minimal sugar that doesn't impede the 31/// user's understanding --- for example, elaborated type 32/// specifiers. If this is all the sugar we see, we don't want an 33/// a.k.a. clause. 34/// 2) Some types are technically sugared but are much more familiar 35/// when seen in their sugared form --- for example, va_list, 36/// vector types, and the magic Objective C types. We don't 37/// want to desugar these, even if we do produce an a.k.a. clause. 38/// 3) Some types may have already been desugared previously in this diagnostic. 39/// if this is the case, doing another "aka" would just be clutter. 40/// 41static bool ShouldAKA(ASTContext &Context, QualType QT, 42 const Diagnostic::ArgumentValue *PrevArgs, 43 unsigned NumPrevArgs, 44 QualType &DesugaredQT) { 45 QualType InputTy = QT; 46 47 bool AKA = false; 48 QualifierCollector Qc; 49 50 while (true) { 51 const Type *Ty = Qc.strip(QT); 52 53 // Don't aka just because we saw an elaborated type... 54 if (isa<ElaboratedType>(Ty)) { 55 QT = cast<ElaboratedType>(Ty)->desugar(); 56 continue; 57 } 58 59 // ...or a qualified name type... 60 if (isa<QualifiedNameType>(Ty)) { 61 QT = cast<QualifiedNameType>(Ty)->desugar(); 62 continue; 63 } 64 65 // ...or a substituted template type parameter. 66 if (isa<SubstTemplateTypeParmType>(Ty)) { 67 QT = cast<SubstTemplateTypeParmType>(Ty)->desugar(); 68 continue; 69 } 70 71 // Don't desugar template specializations. 72 if (isa<TemplateSpecializationType>(Ty)) 73 break; 74 75 // Don't desugar magic Objective-C types. 76 if (QualType(Ty,0) == Context.getObjCIdType() || 77 QualType(Ty,0) == Context.getObjCClassType() || 78 QualType(Ty,0) == Context.getObjCSelType() || 79 QualType(Ty,0) == Context.getObjCProtoType()) 80 break; 81 82 // Don't desugar va_list. 83 if (QualType(Ty,0) == Context.getBuiltinVaListType()) 84 break; 85 86 // Otherwise, do a single-step desugar. 87 QualType Underlying; 88 bool IsSugar = false; 89 switch (Ty->getTypeClass()) { 90#define ABSTRACT_TYPE(Class, Base) 91#define TYPE(Class, Base) \ 92 case Type::Class: { \ 93 const Class##Type *CTy = cast<Class##Type>(Ty); \ 94 if (CTy->isSugared()) { \ 95 IsSugar = true; \ 96 Underlying = CTy->desugar(); \ 97 } \ 98 break; \ 99 } 100#include "clang/AST/TypeNodes.def" 101 } 102 103 // If it wasn't sugared, we're done. 104 if (!IsSugar) 105 break; 106 107 // If the desugared type is a vector type, we don't want to expand 108 // it, it will turn into an attribute mess. People want their "vec4". 109 if (isa<VectorType>(Underlying)) 110 break; 111 112 // Otherwise, we're tearing through something opaque; note that 113 // we'll eventually need an a.k.a. clause and keep going. 114 AKA = true; 115 QT = Underlying; 116 continue; 117 } 118 119 // If we never tore through opaque sugar, don't print aka. 120 if (!AKA) return false; 121 122 // If we did, check to see if we already desugared this type in this 123 // diagnostic. If so, don't do it again. 124 for (unsigned i = 0; i != NumPrevArgs; ++i) { 125 // TODO: Handle ak_declcontext case. 126 if (PrevArgs[i].first == Diagnostic::ak_qualtype) { 127 void *Ptr = (void*)PrevArgs[i].second; 128 QualType PrevTy(QualType::getFromOpaquePtr(Ptr)); 129 if (PrevTy == InputTy) 130 return false; 131 } 132 } 133 134 DesugaredQT = Qc.apply(QT); 135 return true; 136} 137 138/// \brief Convert the given type to a string suitable for printing as part of 139/// a diagnostic. 140/// 141/// \param Context the context in which the type was allocated 142/// \param Ty the type to print 143static std::string 144ConvertTypeToDiagnosticString(ASTContext &Context, QualType Ty, 145 const Diagnostic::ArgumentValue *PrevArgs, 146 unsigned NumPrevArgs) { 147 // FIXME: Playing with std::string is really slow. 148 std::string S = Ty.getAsString(Context.PrintingPolicy); 149 150 // Consider producing an a.k.a. clause if removing all the direct 151 // sugar gives us something "significantly different". 152 153 QualType DesugaredTy; 154 if (ShouldAKA(Context, Ty, PrevArgs, NumPrevArgs, DesugaredTy)) { 155 S = "'"+S+"' (aka '"; 156 S += DesugaredTy.getAsString(Context.PrintingPolicy); 157 S += "')"; 158 return S; 159 } 160 161 S = "'" + S + "'"; 162 return S; 163} 164 165/// ConvertQualTypeToStringFn - This function is used to pretty print the 166/// specified QualType as a string in diagnostics. 167static void ConvertArgToStringFn(Diagnostic::ArgumentKind Kind, intptr_t Val, 168 const char *Modifier, unsigned ModLen, 169 const char *Argument, unsigned ArgLen, 170 const Diagnostic::ArgumentValue *PrevArgs, 171 unsigned NumPrevArgs, 172 llvm::SmallVectorImpl<char> &Output, 173 void *Cookie) { 174 ASTContext &Context = *static_cast<ASTContext*>(Cookie); 175 176 std::string S; 177 bool NeedQuotes = true; 178 179 switch (Kind) { 180 default: assert(0 && "unknown ArgumentKind"); 181 case Diagnostic::ak_qualtype: { 182 assert(ModLen == 0 && ArgLen == 0 && 183 "Invalid modifier for QualType argument"); 184 185 QualType Ty(QualType::getFromOpaquePtr(reinterpret_cast<void*>(Val))); 186 S = ConvertTypeToDiagnosticString(Context, Ty, PrevArgs, NumPrevArgs); 187 NeedQuotes = false; 188 break; 189 } 190 case Diagnostic::ak_declarationname: { 191 DeclarationName N = DeclarationName::getFromOpaqueInteger(Val); 192 S = N.getAsString(); 193 194 if (ModLen == 9 && !memcmp(Modifier, "objcclass", 9) && ArgLen == 0) 195 S = '+' + S; 196 else if (ModLen == 12 && !memcmp(Modifier, "objcinstance", 12) && ArgLen==0) 197 S = '-' + S; 198 else 199 assert(ModLen == 0 && ArgLen == 0 && 200 "Invalid modifier for DeclarationName argument"); 201 break; 202 } 203 case Diagnostic::ak_nameddecl: { 204 bool Qualified; 205 if (ModLen == 1 && Modifier[0] == 'q' && ArgLen == 0) 206 Qualified = true; 207 else { 208 assert(ModLen == 0 && ArgLen == 0 && 209 "Invalid modifier for NamedDecl* argument"); 210 Qualified = false; 211 } 212 reinterpret_cast<NamedDecl*>(Val)-> 213 getNameForDiagnostic(S, Context.PrintingPolicy, Qualified); 214 break; 215 } 216 case Diagnostic::ak_nestednamespec: { 217 llvm::raw_string_ostream OS(S); 218 reinterpret_cast<NestedNameSpecifier*>(Val)->print(OS, 219 Context.PrintingPolicy); 220 NeedQuotes = false; 221 break; 222 } 223 case Diagnostic::ak_declcontext: { 224 DeclContext *DC = reinterpret_cast<DeclContext *> (Val); 225 assert(DC && "Should never have a null declaration context"); 226 227 if (DC->isTranslationUnit()) { 228 // FIXME: Get these strings from some localized place 229 if (Context.getLangOptions().CPlusPlus) 230 S = "the global namespace"; 231 else 232 S = "the global scope"; 233 } else if (TypeDecl *Type = dyn_cast<TypeDecl>(DC)) { 234 S = ConvertTypeToDiagnosticString(Context, Context.getTypeDeclType(Type), 235 PrevArgs, NumPrevArgs); 236 } else { 237 // FIXME: Get these strings from some localized place 238 NamedDecl *ND = cast<NamedDecl>(DC); 239 if (isa<NamespaceDecl>(ND)) 240 S += "namespace "; 241 else if (isa<ObjCMethodDecl>(ND)) 242 S += "method "; 243 else if (isa<FunctionDecl>(ND)) 244 S += "function "; 245 246 S += "'"; 247 ND->getNameForDiagnostic(S, Context.PrintingPolicy, true); 248 S += "'"; 249 } 250 NeedQuotes = false; 251 break; 252 } 253 } 254 255 if (NeedQuotes) 256 Output.push_back('\''); 257 258 Output.append(S.begin(), S.end()); 259 260 if (NeedQuotes) 261 Output.push_back('\''); 262} 263 264 265static inline RecordDecl *CreateStructDecl(ASTContext &C, const char *Name) { 266 if (C.getLangOptions().CPlusPlus) 267 return CXXRecordDecl::Create(C, TagDecl::TK_struct, 268 C.getTranslationUnitDecl(), 269 SourceLocation(), &C.Idents.get(Name)); 270 271 return RecordDecl::Create(C, TagDecl::TK_struct, 272 C.getTranslationUnitDecl(), 273 SourceLocation(), &C.Idents.get(Name)); 274} 275 276void Sema::ActOnTranslationUnitScope(SourceLocation Loc, Scope *S) { 277 TUScope = S; 278 PushDeclContext(S, Context.getTranslationUnitDecl()); 279 280 if (PP.getTargetInfo().getPointerWidth(0) >= 64) { 281 DeclaratorInfo *DInfo; 282 283 // Install [u]int128_t for 64-bit targets. 284 DInfo = Context.getTrivialDeclaratorInfo(Context.Int128Ty); 285 PushOnScopeChains(TypedefDecl::Create(Context, CurContext, 286 SourceLocation(), 287 &Context.Idents.get("__int128_t"), 288 DInfo), TUScope); 289 290 DInfo = Context.getTrivialDeclaratorInfo(Context.UnsignedInt128Ty); 291 PushOnScopeChains(TypedefDecl::Create(Context, CurContext, 292 SourceLocation(), 293 &Context.Idents.get("__uint128_t"), 294 DInfo), TUScope); 295 } 296 297 298 if (!PP.getLangOptions().ObjC1) return; 299 300 // Built-in ObjC types may already be set by PCHReader (hence isNull checks). 301 if (Context.getObjCSelType().isNull()) { 302 // Synthesize "typedef struct objc_selector *SEL;" 303 RecordDecl *SelTag = CreateStructDecl(Context, "objc_selector"); 304 PushOnScopeChains(SelTag, TUScope); 305 306 QualType SelT = Context.getPointerType(Context.getTagDeclType(SelTag)); 307 DeclaratorInfo *SelInfo = Context.getTrivialDeclaratorInfo(SelT); 308 TypedefDecl *SelTypedef 309 = TypedefDecl::Create(Context, CurContext, SourceLocation(), 310 &Context.Idents.get("SEL"), SelInfo); 311 PushOnScopeChains(SelTypedef, TUScope); 312 Context.setObjCSelType(Context.getTypeDeclType(SelTypedef)); 313 } 314 315 // Synthesize "@class Protocol; 316 if (Context.getObjCProtoType().isNull()) { 317 ObjCInterfaceDecl *ProtocolDecl = 318 ObjCInterfaceDecl::Create(Context, CurContext, SourceLocation(), 319 &Context.Idents.get("Protocol"), 320 SourceLocation(), true); 321 Context.setObjCProtoType(Context.getObjCInterfaceType(ProtocolDecl)); 322 PushOnScopeChains(ProtocolDecl, TUScope, false); 323 } 324 // Create the built-in typedef for 'id'. 325 if (Context.getObjCIdType().isNull()) { 326 QualType IdT = Context.getObjCObjectPointerType(Context.ObjCBuiltinIdTy); 327 DeclaratorInfo *IdInfo = Context.getTrivialDeclaratorInfo(IdT); 328 TypedefDecl *IdTypedef 329 = TypedefDecl::Create(Context, CurContext, SourceLocation(), 330 &Context.Idents.get("id"), IdInfo); 331 PushOnScopeChains(IdTypedef, TUScope); 332 Context.setObjCIdType(Context.getTypeDeclType(IdTypedef)); 333 Context.ObjCIdRedefinitionType = Context.getObjCIdType(); 334 } 335 // Create the built-in typedef for 'Class'. 336 if (Context.getObjCClassType().isNull()) { 337 QualType ClassType 338 = Context.getObjCObjectPointerType(Context.ObjCBuiltinClassTy); 339 DeclaratorInfo *ClassInfo = Context.getTrivialDeclaratorInfo(ClassType); 340 TypedefDecl *ClassTypedef 341 = TypedefDecl::Create(Context, CurContext, SourceLocation(), 342 &Context.Idents.get("Class"), ClassInfo); 343 PushOnScopeChains(ClassTypedef, TUScope); 344 Context.setObjCClassType(Context.getTypeDeclType(ClassTypedef)); 345 Context.ObjCClassRedefinitionType = Context.getObjCClassType(); 346 } 347} 348 349Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, 350 bool CompleteTranslationUnit, 351 CodeCompleteConsumer *CodeCompleter) 352 : LangOpts(pp.getLangOptions()), PP(pp), Context(ctxt), Consumer(consumer), 353 Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()), 354 ExternalSource(0), CodeCompleter(CodeCompleter), CurContext(0), 355 PreDeclaratorDC(0), CurBlock(0), PackContext(0), ParsingDeclDepth(0), 356 IdResolver(pp.getLangOptions()), StdNamespace(0), StdBadAlloc(0), 357 GlobalNewDeleteDeclared(false), ExprEvalContext(PotentiallyEvaluated), 358 CompleteTranslationUnit(CompleteTranslationUnit), 359 NumSFINAEErrors(0), NonInstantiationEntries(0), 360 CurrentInstantiationScope(0) 361{ 362 TUScope = 0; 363 if (getLangOptions().CPlusPlus) 364 FieldCollector.reset(new CXXFieldCollector()); 365 366 // Tell diagnostics how to render things from the AST library. 367 PP.getDiagnostics().SetArgToStringFn(ConvertArgToStringFn, &Context); 368} 369 370/// Retrieves the width and signedness of the given integer type, 371/// or returns false if it is not an integer type. 372/// 373/// \param T must be canonical 374static bool getIntProperties(ASTContext &C, const Type *T, 375 unsigned &BitWidth, bool &Signed) { 376 assert(T->isCanonicalUnqualified()); 377 378 if (const VectorType *VT = dyn_cast<VectorType>(T)) 379 T = VT->getElementType().getTypePtr(); 380 if (const ComplexType *CT = dyn_cast<ComplexType>(T)) 381 T = CT->getElementType().getTypePtr(); 382 383 if (const BuiltinType *BT = dyn_cast<BuiltinType>(T)) { 384 if (!BT->isInteger()) return false; 385 386 BitWidth = C.getIntWidth(QualType(T, 0)); 387 Signed = BT->isSignedInteger(); 388 return true; 389 } 390 391 if (const FixedWidthIntType *FWIT = dyn_cast<FixedWidthIntType>(T)) { 392 BitWidth = FWIT->getWidth(); 393 Signed = FWIT->isSigned(); 394 return true; 395 } 396 397 return false; 398} 399 400/// Checks whether the given value will have the same value if it it 401/// is truncated to the given width, then extended back to the 402/// original width. 403static bool IsSameIntAfterCast(const llvm::APSInt &value, 404 unsigned TargetWidth) { 405 unsigned SourceWidth = value.getBitWidth(); 406 llvm::APSInt truncated = value; 407 truncated.trunc(TargetWidth); 408 truncated.extend(SourceWidth); 409 return (truncated == value); 410} 411 412/// Checks whether the given value will have the same value if it 413/// is truncated to the given width, then extended back to the original 414/// width. 415/// 416/// The value might be a vector or a complex. 417static bool IsSameIntAfterCast(const APValue &value, unsigned TargetWidth) { 418 if (value.isInt()) 419 return IsSameIntAfterCast(value.getInt(), TargetWidth); 420 421 if (value.isVector()) { 422 for (unsigned i = 0, e = value.getVectorLength(); i != e; ++i) 423 if (!IsSameIntAfterCast(value.getVectorElt(i), TargetWidth)) 424 return false; 425 return true; 426 } 427 428 if (value.isComplexInt()) { 429 return IsSameIntAfterCast(value.getComplexIntReal(), TargetWidth) && 430 IsSameIntAfterCast(value.getComplexIntImag(), TargetWidth); 431 } 432 433 // This can happen with lossless casts to intptr_t of "based" lvalues. 434 // Assume it might use arbitrary bits. 435 assert(value.isLValue()); 436 return false; 437} 438 439 440/// Checks whether the given value, which currently has the given 441/// source semantics, has the same value when coerced through the 442/// target semantics. 443static bool IsSameFloatAfterCast(const llvm::APFloat &value, 444 const llvm::fltSemantics &Src, 445 const llvm::fltSemantics &Tgt) { 446 llvm::APFloat truncated = value; 447 448 bool ignored; 449 truncated.convert(Src, llvm::APFloat::rmNearestTiesToEven, &ignored); 450 truncated.convert(Tgt, llvm::APFloat::rmNearestTiesToEven, &ignored); 451 452 return truncated.bitwiseIsEqual(value); 453} 454 455/// Checks whether the given value, which currently has the given 456/// source semantics, has the same value when coerced through the 457/// target semantics. 458/// 459/// The value might be a vector of floats (or a complex number). 460static bool IsSameFloatAfterCast(const APValue &value, 461 const llvm::fltSemantics &Src, 462 const llvm::fltSemantics &Tgt) { 463 if (value.isFloat()) 464 return IsSameFloatAfterCast(value.getFloat(), Src, Tgt); 465 466 if (value.isVector()) { 467 for (unsigned i = 0, e = value.getVectorLength(); i != e; ++i) 468 if (!IsSameFloatAfterCast(value.getVectorElt(i), Src, Tgt)) 469 return false; 470 return true; 471 } 472 473 assert(value.isComplexFloat()); 474 return (IsSameFloatAfterCast(value.getComplexFloatReal(), Src, Tgt) && 475 IsSameFloatAfterCast(value.getComplexFloatImag(), Src, Tgt)); 476} 477 478/// Determines if it's reasonable for the given expression to be truncated 479/// down to the given integer width. 480/// * Boolean expressions are automatically white-listed. 481/// * Arithmetic operations on implicitly-promoted operands of the 482/// target width or less are okay --- not because the results are 483/// actually guaranteed to fit within the width, but because the 484/// user is effectively pretending that the operations are closed 485/// within the implicitly-promoted type. 486static bool IsExprValueWithinWidth(ASTContext &C, Expr *E, unsigned Width) { 487 E = E->IgnoreParens(); 488 489#ifndef NDEBUG 490 { 491 const Type *ETy = E->getType()->getCanonicalTypeInternal().getTypePtr(); 492 unsigned EWidth; 493 bool ESigned; 494 495 if (!getIntProperties(C, ETy, EWidth, ESigned)) 496 assert(0 && "expression not of integer type"); 497 498 // The caller should never let this happen. 499 assert(EWidth > Width && "called on expr whose type is too small"); 500 } 501#endif 502 503 // Strip implicit casts off. 504 while (isa<ImplicitCastExpr>(E)) { 505 E = cast<ImplicitCastExpr>(E)->getSubExpr(); 506 507 const Type *ETy = E->getType()->getCanonicalTypeInternal().getTypePtr(); 508 509 unsigned EWidth; 510 bool ESigned; 511 if (!getIntProperties(C, ETy, EWidth, ESigned)) 512 return false; 513 514 if (EWidth <= Width) 515 return true; 516 } 517 518 if (BinaryOperator *BO = dyn_cast<BinaryOperator>(E)) { 519 switch (BO->getOpcode()) { 520 521 // Boolean-valued operations are white-listed. 522 case BinaryOperator::LAnd: 523 case BinaryOperator::LOr: 524 case BinaryOperator::LT: 525 case BinaryOperator::GT: 526 case BinaryOperator::LE: 527 case BinaryOperator::GE: 528 case BinaryOperator::EQ: 529 case BinaryOperator::NE: 530 return true; 531 532 // Operations with opaque sources are black-listed. 533 case BinaryOperator::PtrMemD: 534 case BinaryOperator::PtrMemI: 535 return false; 536 537 // Left shift gets black-listed based on a judgement call. 538 case BinaryOperator::Shl: 539 return false; 540 541 // Various special cases. 542 case BinaryOperator::Shr: 543 return IsExprValueWithinWidth(C, BO->getLHS(), Width); 544 case BinaryOperator::Comma: 545 return IsExprValueWithinWidth(C, BO->getRHS(), Width); 546 case BinaryOperator::Sub: 547 if (BO->getLHS()->getType()->isPointerType()) 548 return false; 549 // fallthrough 550 551 // Any other operator is okay if the operands are 552 // promoted from expressions of appropriate size. 553 default: 554 return IsExprValueWithinWidth(C, BO->getLHS(), Width) && 555 IsExprValueWithinWidth(C, BO->getRHS(), Width); 556 } 557 } 558 559 if (UnaryOperator *UO = dyn_cast<UnaryOperator>(E)) { 560 switch (UO->getOpcode()) { 561 // Boolean-valued operations are white-listed. 562 case UnaryOperator::LNot: 563 return true; 564 565 // Operations with opaque sources are black-listed. 566 case UnaryOperator::Deref: 567 case UnaryOperator::AddrOf: // should be impossible 568 return false; 569 570 case UnaryOperator::OffsetOf: 571 return false; 572 573 default: 574 return IsExprValueWithinWidth(C, UO->getSubExpr(), Width); 575 } 576 } 577 578 // Don't diagnose if the expression is an integer constant 579 // whose value in the target type is the same as it was 580 // in the original type. 581 Expr::EvalResult result; 582 if (E->Evaluate(result, C)) 583 if (IsSameIntAfterCast(result.Val, Width)) 584 return true; 585 586 return false; 587} 588 589/// Diagnose an implicit cast; purely a helper for CheckImplicitConversion. 590static void DiagnoseImpCast(Sema &S, Expr *E, QualType T, unsigned diag) { 591 S.Diag(E->getExprLoc(), diag) << E->getType() << T << E->getSourceRange(); 592} 593 594/// Implements -Wconversion. 595static void CheckImplicitConversion(Sema &S, Expr *E, QualType T) { 596 // Don't diagnose in unevaluated contexts. 597 if (S.ExprEvalContext == Sema::Unevaluated) 598 return; 599 600 // Don't diagnose for value-dependent expressions. 601 if (E->isValueDependent()) 602 return; 603 604 const Type *Source = S.Context.getCanonicalType(E->getType()).getTypePtr(); 605 const Type *Target = S.Context.getCanonicalType(T).getTypePtr(); 606 607 // Never diagnose implicit casts to bool. 608 if (Target->isSpecificBuiltinType(BuiltinType::Bool)) 609 return; 610 611 // Strip vector types. 612 if (isa<VectorType>(Source)) { 613 if (!isa<VectorType>(Target)) 614 return DiagnoseImpCast(S, E, T, diag::warn_impcast_vector_scalar); 615 616 Source = cast<VectorType>(Source)->getElementType().getTypePtr(); 617 Target = cast<VectorType>(Target)->getElementType().getTypePtr(); 618 } 619 620 // Strip complex types. 621 if (isa<ComplexType>(Source)) { 622 if (!isa<ComplexType>(Target)) 623 return DiagnoseImpCast(S, E, T, diag::warn_impcast_complex_scalar); 624 625 Source = cast<ComplexType>(Source)->getElementType().getTypePtr(); 626 Target = cast<ComplexType>(Target)->getElementType().getTypePtr(); 627 } 628 629 const BuiltinType *SourceBT = dyn_cast<BuiltinType>(Source); 630 const BuiltinType *TargetBT = dyn_cast<BuiltinType>(Target); 631 632 // If the source is floating point... 633 if (SourceBT && SourceBT->isFloatingPoint()) { 634 // ...and the target is floating point... 635 if (TargetBT && TargetBT->isFloatingPoint()) { 636 // ...then warn if we're dropping FP rank. 637 638 // Builtin FP kinds are ordered by increasing FP rank. 639 if (SourceBT->getKind() > TargetBT->getKind()) { 640 // Don't warn about float constants that are precisely 641 // representable in the target type. 642 Expr::EvalResult result; 643 if (E->Evaluate(result, S.Context)) { 644 // Value might be a float, a float vector, or a float complex. 645 if (IsSameFloatAfterCast(result.Val, 646 S.Context.getFloatTypeSemantics(QualType(TargetBT, 0)), 647 S.Context.getFloatTypeSemantics(QualType(SourceBT, 0)))) 648 return; 649 } 650 651 DiagnoseImpCast(S, E, T, diag::warn_impcast_float_precision); 652 } 653 return; 654 } 655 656 // If the target is integral, always warn. 657 if ((TargetBT && TargetBT->isInteger()) || 658 isa<FixedWidthIntType>(Target)) 659 // TODO: don't warn for integer values? 660 return DiagnoseImpCast(S, E, T, diag::warn_impcast_float_integer); 661 662 return; 663 } 664 665 unsigned SourceWidth, TargetWidth; 666 bool SourceSigned, TargetSigned; 667 668 if (!getIntProperties(S.Context, Source, SourceWidth, SourceSigned) || 669 !getIntProperties(S.Context, Target, TargetWidth, TargetSigned)) 670 return; 671 672 if (SourceWidth > TargetWidth) { 673 if (IsExprValueWithinWidth(S.Context, E, TargetWidth)) 674 return; 675 676 // People want to build with -Wshorten-64-to-32 and not -Wconversion 677 // and by god we'll let them. 678 if (SourceWidth == 64 && TargetWidth == 32) 679 return DiagnoseImpCast(S, E, T, diag::warn_impcast_integer_64_32); 680 return DiagnoseImpCast(S, E, T, diag::warn_impcast_integer_precision); 681 } 682 683 return; 684} 685 686/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast. 687/// If there is already an implicit cast, merge into the existing one. 688/// If isLvalue, the result of the cast is an lvalue. 689void Sema::ImpCastExprToType(Expr *&Expr, QualType Ty, 690 CastExpr::CastKind Kind, bool isLvalue) { 691 QualType ExprTy = Context.getCanonicalType(Expr->getType()); 692 QualType TypeTy = Context.getCanonicalType(Ty); 693 694 if (ExprTy == TypeTy) 695 return; 696 697 if (Expr->getType()->isPointerType() && Ty->isPointerType()) { 698 QualType ExprBaseType = cast<PointerType>(ExprTy)->getPointeeType(); 699 QualType BaseType = cast<PointerType>(TypeTy)->getPointeeType(); 700 if (ExprBaseType.getAddressSpace() != BaseType.getAddressSpace()) { 701 Diag(Expr->getExprLoc(), diag::err_implicit_pointer_address_space_cast) 702 << Expr->getSourceRange(); 703 } 704 } 705 706 CheckImplicitConversion(*this, Expr, Ty); 707 708 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(Expr)) { 709 if (ImpCast->getCastKind() == Kind) { 710 ImpCast->setType(Ty); 711 ImpCast->setLvalueCast(isLvalue); 712 return; 713 } 714 } 715 716 Expr = new (Context) ImplicitCastExpr(Ty, Kind, Expr, isLvalue); 717} 718 719void Sema::DeleteExpr(ExprTy *E) { 720 if (E) static_cast<Expr*>(E)->Destroy(Context); 721} 722void Sema::DeleteStmt(StmtTy *S) { 723 if (S) static_cast<Stmt*>(S)->Destroy(Context); 724} 725 726/// ActOnEndOfTranslationUnit - This is called at the very end of the 727/// translation unit when EOF is reached and all but the top-level scope is 728/// popped. 729void Sema::ActOnEndOfTranslationUnit() { 730 // C++: Perform implicit template instantiations. 731 // 732 // FIXME: When we perform these implicit instantiations, we do not carefully 733 // keep track of the point of instantiation (C++ [temp.point]). This means 734 // that name lookup that occurs within the template instantiation will 735 // always happen at the end of the translation unit, so it will find 736 // some names that should not be found. Although this is common behavior 737 // for C++ compilers, it is technically wrong. In the future, we either need 738 // to be able to filter the results of name lookup or we need to perform 739 // template instantiations earlier. 740 PerformPendingImplicitInstantiations(); 741 742 // Check for #pragma weak identifiers that were never declared 743 // FIXME: This will cause diagnostics to be emitted in a non-determinstic 744 // order! Iterating over a densemap like this is bad. 745 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator 746 I = WeakUndeclaredIdentifiers.begin(), 747 E = WeakUndeclaredIdentifiers.end(); I != E; ++I) { 748 if (I->second.getUsed()) continue; 749 750 Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared) 751 << I->first; 752 } 753 754 if (!CompleteTranslationUnit) 755 return; 756 757 // C99 6.9.2p2: 758 // A declaration of an identifier for an object that has file 759 // scope without an initializer, and without a storage-class 760 // specifier or with the storage-class specifier static, 761 // constitutes a tentative definition. If a translation unit 762 // contains one or more tentative definitions for an identifier, 763 // and the translation unit contains no external definition for 764 // that identifier, then the behavior is exactly as if the 765 // translation unit contains a file scope declaration of that 766 // identifier, with the composite type as of the end of the 767 // translation unit, with an initializer equal to 0. 768 for (unsigned i = 0, e = TentativeDefinitionList.size(); i != e; ++i) { 769 VarDecl *VD = TentativeDefinitions.lookup(TentativeDefinitionList[i]); 770 771 // If the tentative definition was completed, it will be in the list, but 772 // not the map. 773 if (VD == 0 || VD->isInvalidDecl() || !VD->isTentativeDefinition(Context)) 774 continue; 775 776 if (const IncompleteArrayType *ArrayT 777 = Context.getAsIncompleteArrayType(VD->getType())) { 778 if (RequireCompleteType(VD->getLocation(), 779 ArrayT->getElementType(), 780 diag::err_tentative_def_incomplete_type_arr)) { 781 VD->setInvalidDecl(); 782 continue; 783 } 784 785 // Set the length of the array to 1 (C99 6.9.2p5). 786 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array); 787 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true); 788 QualType T = Context.getConstantArrayType(ArrayT->getElementType(), 789 One, ArrayType::Normal, 0); 790 VD->setType(T); 791 } else if (RequireCompleteType(VD->getLocation(), VD->getType(), 792 diag::err_tentative_def_incomplete_type)) 793 VD->setInvalidDecl(); 794 795 // Notify the consumer that we've completed a tentative definition. 796 if (!VD->isInvalidDecl()) 797 Consumer.CompleteTentativeDefinition(VD); 798 799 } 800} 801 802 803//===----------------------------------------------------------------------===// 804// Helper functions. 805//===----------------------------------------------------------------------===// 806 807DeclContext *Sema::getFunctionLevelDeclContext() { 808 DeclContext *DC = PreDeclaratorDC ? PreDeclaratorDC : CurContext; 809 810 while (isa<BlockDecl>(DC)) 811 DC = DC->getParent(); 812 813 return DC; 814} 815 816/// getCurFunctionDecl - If inside of a function body, this returns a pointer 817/// to the function decl for the function being parsed. If we're currently 818/// in a 'block', this returns the containing context. 819FunctionDecl *Sema::getCurFunctionDecl() { 820 DeclContext *DC = getFunctionLevelDeclContext(); 821 return dyn_cast<FunctionDecl>(DC); 822} 823 824ObjCMethodDecl *Sema::getCurMethodDecl() { 825 DeclContext *DC = getFunctionLevelDeclContext(); 826 return dyn_cast<ObjCMethodDecl>(DC); 827} 828 829NamedDecl *Sema::getCurFunctionOrMethodDecl() { 830 DeclContext *DC = getFunctionLevelDeclContext(); 831 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC)) 832 return cast<NamedDecl>(DC); 833 return 0; 834} 835 836Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() { 837 if (!this->Emit()) 838 return; 839 840 // If this is not a note, and we're in a template instantiation 841 // that is different from the last template instantiation where 842 // we emitted an error, print a template instantiation 843 // backtrace. 844 if (!SemaRef.Diags.isBuiltinNote(DiagID) && 845 !SemaRef.ActiveTemplateInstantiations.empty() && 846 SemaRef.ActiveTemplateInstantiations.back() 847 != SemaRef.LastTemplateInstantiationErrorContext) { 848 SemaRef.PrintInstantiationStack(); 849 SemaRef.LastTemplateInstantiationErrorContext 850 = SemaRef.ActiveTemplateInstantiations.back(); 851 } 852} 853 854Sema::SemaDiagnosticBuilder 855Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { 856 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID())); 857 PD.Emit(Builder); 858 859 return Builder; 860} 861 862void Sema::ActOnComment(SourceRange Comment) { 863 Context.Comments.push_back(Comment); 864} 865 866