Sema.cpp revision 05eac86d547892847ca95b5350e28d681150fa68
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 "clang/Sema/Sema.h" 16#include "TargetAttributesSema.h" 17#include "llvm/ADT/DenseMap.h" 18#include "llvm/ADT/SmallSet.h" 19#include "llvm/ADT/APFloat.h" 20#include "clang/Sema/ExternalSemaSource.h" 21#include "clang/Sema/SemaConsumer.h" 22#include "clang/AST/ASTContext.h" 23#include "clang/AST/ASTDiagnostic.h" 24#include "clang/AST/DeclObjC.h" 25#include "clang/AST/Expr.h" 26#include "clang/Lex/Preprocessor.h" 27#include "clang/Basic/PartialDiagnostic.h" 28#include "clang/Basic/TargetInfo.h" 29using namespace clang; 30 31FunctionScopeInfo::~FunctionScopeInfo() { } 32 33void FunctionScopeInfo::Clear(unsigned NumErrors) { 34 HasBranchProtectedScope = false; 35 HasBranchIntoScope = false; 36 HasIndirectGoto = false; 37 38 LabelMap.clear(); 39 SwitchStack.clear(); 40 Returns.clear(); 41 NumErrorsAtStartOfFunction = NumErrors; 42} 43 44BlockScopeInfo::~BlockScopeInfo() { } 45 46void Sema::ActOnTranslationUnitScope(SourceLocation Loc, Scope *S) { 47 TUScope = S; 48 PushDeclContext(S, Context.getTranslationUnitDecl()); 49 50 VAListTagName = PP.getIdentifierInfo("__va_list_tag"); 51 52 if (!Context.isInt128Installed() && // May be set by PCHReader. 53 PP.getTargetInfo().getPointerWidth(0) >= 64) { 54 TypeSourceInfo *TInfo; 55 56 // Install [u]int128_t for 64-bit targets. 57 TInfo = Context.getTrivialTypeSourceInfo(Context.Int128Ty); 58 PushOnScopeChains(TypedefDecl::Create(Context, CurContext, 59 SourceLocation(), 60 &Context.Idents.get("__int128_t"), 61 TInfo), TUScope); 62 63 TInfo = Context.getTrivialTypeSourceInfo(Context.UnsignedInt128Ty); 64 PushOnScopeChains(TypedefDecl::Create(Context, CurContext, 65 SourceLocation(), 66 &Context.Idents.get("__uint128_t"), 67 TInfo), TUScope); 68 Context.setInt128Installed(); 69 } 70 71 72 if (!PP.getLangOptions().ObjC1) return; 73 74 // Built-in ObjC types may already be set by PCHReader (hence isNull checks). 75 if (Context.getObjCSelType().isNull()) { 76 // Create the built-in typedef for 'SEL'. 77 QualType SelT = Context.getPointerType(Context.ObjCBuiltinSelTy); 78 TypeSourceInfo *SelInfo = Context.getTrivialTypeSourceInfo(SelT); 79 TypedefDecl *SelTypedef 80 = TypedefDecl::Create(Context, CurContext, SourceLocation(), 81 &Context.Idents.get("SEL"), SelInfo); 82 PushOnScopeChains(SelTypedef, TUScope); 83 Context.setObjCSelType(Context.getTypeDeclType(SelTypedef)); 84 Context.ObjCSelRedefinitionType = Context.getObjCSelType(); 85 } 86 87 // Synthesize "@class Protocol; 88 if (Context.getObjCProtoType().isNull()) { 89 ObjCInterfaceDecl *ProtocolDecl = 90 ObjCInterfaceDecl::Create(Context, CurContext, SourceLocation(), 91 &Context.Idents.get("Protocol"), 92 SourceLocation(), true); 93 Context.setObjCProtoType(Context.getObjCInterfaceType(ProtocolDecl)); 94 PushOnScopeChains(ProtocolDecl, TUScope, false); 95 } 96 // Create the built-in typedef for 'id'. 97 if (Context.getObjCIdType().isNull()) { 98 QualType T = Context.getObjCObjectType(Context.ObjCBuiltinIdTy, 0, 0); 99 T = Context.getObjCObjectPointerType(T); 100 TypeSourceInfo *IdInfo = Context.getTrivialTypeSourceInfo(T); 101 TypedefDecl *IdTypedef 102 = TypedefDecl::Create(Context, CurContext, SourceLocation(), 103 &Context.Idents.get("id"), IdInfo); 104 PushOnScopeChains(IdTypedef, TUScope); 105 Context.setObjCIdType(Context.getTypeDeclType(IdTypedef)); 106 Context.ObjCIdRedefinitionType = Context.getObjCIdType(); 107 } 108 // Create the built-in typedef for 'Class'. 109 if (Context.getObjCClassType().isNull()) { 110 QualType T = Context.getObjCObjectType(Context.ObjCBuiltinClassTy, 0, 0); 111 T = Context.getObjCObjectPointerType(T); 112 TypeSourceInfo *ClassInfo = Context.getTrivialTypeSourceInfo(T); 113 TypedefDecl *ClassTypedef 114 = TypedefDecl::Create(Context, CurContext, SourceLocation(), 115 &Context.Idents.get("Class"), ClassInfo); 116 PushOnScopeChains(ClassTypedef, TUScope); 117 Context.setObjCClassType(Context.getTypeDeclType(ClassTypedef)); 118 Context.ObjCClassRedefinitionType = Context.getObjCClassType(); 119 } 120} 121 122Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, 123 bool CompleteTranslationUnit, 124 CodeCompleteConsumer *CodeCompleter) 125 : TheTargetAttributesSema(0), 126 LangOpts(pp.getLangOptions()), PP(pp), Context(ctxt), Consumer(consumer), 127 Diags(PP.getDiagnostics()), SourceMgr(PP.getSourceManager()), 128 ExternalSource(0), CodeCompleter(CodeCompleter), CurContext(0), 129 PackContext(0), VisContext(0), TopFunctionScope(0), ParsingDeclDepth(0), 130 IdResolver(pp.getLangOptions()), GlobalNewDeleteDeclared(false), 131 CompleteTranslationUnit(CompleteTranslationUnit), 132 NumSFINAEErrors(0), SuppressAccessChecking(false), 133 NonInstantiationEntries(0), CurrentInstantiationScope(0), TyposCorrected(0), 134 AnalysisWarnings(*this) 135{ 136 TUScope = 0; 137 if (getLangOptions().CPlusPlus) 138 FieldCollector.reset(new CXXFieldCollector()); 139 140 // Tell diagnostics how to render things from the AST library. 141 PP.getDiagnostics().SetArgToStringFn(&FormatASTNodeDiagnosticArgument, 142 &Context); 143 144 ExprEvalContexts.push_back( 145 ExpressionEvaluationContextRecord(PotentiallyEvaluated, 0)); 146} 147 148void Sema::Initialize() { 149 // Tell the AST consumer about this Sema object. 150 Consumer.Initialize(Context); 151 152 // FIXME: Isn't this redundant with the initialization above? 153 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer)) 154 SC->InitializeSema(*this); 155 156 // Tell the external Sema source about this Sema object. 157 if (ExternalSemaSource *ExternalSema 158 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource())) 159 ExternalSema->InitializeSema(*this); 160} 161 162Sema::~Sema() { 163 if (PackContext) FreePackedContext(); 164 if (VisContext) FreeVisContext(); 165 delete TheTargetAttributesSema; 166 while (!FunctionScopes.empty()) 167 PopFunctionOrBlockScope(); 168 169 // Tell the SemaConsumer to forget about us; we're going out of scope. 170 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer)) 171 SC->ForgetSema(); 172 173 // Detach from the external Sema source. 174 if (ExternalSemaSource *ExternalSema 175 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource())) 176 ExternalSema->ForgetSema(); 177} 178 179/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast. 180/// If there is already an implicit cast, merge into the existing one. 181/// The result is of the given category. 182void Sema::ImpCastExprToType(Expr *&Expr, QualType Ty, 183 CastExpr::CastKind Kind, 184 ImplicitCastExpr::ResultCategory Category, 185 const CXXCastPath *BasePath) { 186 QualType ExprTy = Context.getCanonicalType(Expr->getType()); 187 QualType TypeTy = Context.getCanonicalType(Ty); 188 189 if (ExprTy == TypeTy) 190 return; 191 192 if (Expr->getType()->isPointerType() && Ty->isPointerType()) { 193 QualType ExprBaseType = cast<PointerType>(ExprTy)->getPointeeType(); 194 QualType BaseType = cast<PointerType>(TypeTy)->getPointeeType(); 195 if (ExprBaseType.getAddressSpace() != BaseType.getAddressSpace()) { 196 Diag(Expr->getExprLoc(), diag::err_implicit_pointer_address_space_cast) 197 << Expr->getSourceRange(); 198 } 199 } 200 201 // If this is a derived-to-base cast to a through a virtual base, we 202 // need a vtable. 203 if (Kind == CastExpr::CK_DerivedToBase && 204 BasePathInvolvesVirtualBase(*BasePath)) { 205 QualType T = Expr->getType(); 206 if (const PointerType *Pointer = T->getAs<PointerType>()) 207 T = Pointer->getPointeeType(); 208 if (const RecordType *RecordTy = T->getAs<RecordType>()) 209 MarkVTableUsed(Expr->getLocStart(), 210 cast<CXXRecordDecl>(RecordTy->getDecl())); 211 } 212 213 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(Expr)) { 214 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) { 215 ImpCast->setType(Ty); 216 ImpCast->setCategory(Category); 217 return; 218 } 219 } 220 221 Expr = ImplicitCastExpr::Create(Context, Ty, Kind, Expr, BasePath, Category); 222} 223 224ImplicitCastExpr::ResultCategory Sema::CastCategory(Expr *E) { 225 Expr::Classification Classification = E->Classify(Context); 226 return Classification.isRValue() ? 227 ImplicitCastExpr::RValue : 228 (Classification.isLValue() ? 229 ImplicitCastExpr::LValue : 230 ImplicitCastExpr::XValue); 231} 232 233void Sema::DeleteExpr(ExprTy *E) { 234} 235void Sema::DeleteStmt(StmtTy *S) { 236} 237 238/// ActOnEndOfTranslationUnit - This is called at the very end of the 239/// translation unit when EOF is reached and all but the top-level scope is 240/// popped. 241void Sema::ActOnEndOfTranslationUnit() { 242 // At PCH writing, implicit instantiations and VTable handling info are 243 // stored and performed when the PCH is included. 244 if (CompleteTranslationUnit) 245 while (1) { 246 // C++: Perform implicit template instantiations. 247 // 248 // FIXME: When we perform these implicit instantiations, we do not 249 // carefully keep track of the point of instantiation (C++ [temp.point]). 250 // This means that name lookup that occurs within the template 251 // instantiation will always happen at the end of the translation unit, 252 // so it will find some names that should not be found. Although this is 253 // common behavior for C++ compilers, it is technically wrong. In the 254 // future, we either need to be able to filter the results of name lookup 255 // or we need to perform template instantiations earlier. 256 PerformPendingImplicitInstantiations(); 257 258 /// If DefinedUsedVTables ends up marking any virtual member 259 /// functions it might lead to more pending template 260 /// instantiations, which is why we need to loop here. 261 if (!DefineUsedVTables()) 262 break; 263 } 264 265 // Remove file scoped decls that turned out to be used. 266 UnusedFileScopedDecls.erase(std::remove_if(UnusedFileScopedDecls.begin(), 267 UnusedFileScopedDecls.end(), 268 std::bind2nd(std::mem_fun(&DeclaratorDecl::isUsed), 269 true)), 270 UnusedFileScopedDecls.end()); 271 272 if (!CompleteTranslationUnit) 273 return; 274 275 // Check for #pragma weak identifiers that were never declared 276 // FIXME: This will cause diagnostics to be emitted in a non-determinstic 277 // order! Iterating over a densemap like this is bad. 278 for (llvm::DenseMap<IdentifierInfo*,WeakInfo>::iterator 279 I = WeakUndeclaredIdentifiers.begin(), 280 E = WeakUndeclaredIdentifiers.end(); I != E; ++I) { 281 if (I->second.getUsed()) continue; 282 283 Diag(I->second.getLocation(), diag::warn_weak_identifier_undeclared) 284 << I->first; 285 } 286 287 // C99 6.9.2p2: 288 // A declaration of an identifier for an object that has file 289 // scope without an initializer, and without a storage-class 290 // specifier or with the storage-class specifier static, 291 // constitutes a tentative definition. If a translation unit 292 // contains one or more tentative definitions for an identifier, 293 // and the translation unit contains no external definition for 294 // that identifier, then the behavior is exactly as if the 295 // translation unit contains a file scope declaration of that 296 // identifier, with the composite type as of the end of the 297 // translation unit, with an initializer equal to 0. 298 llvm::SmallSet<VarDecl *, 32> Seen; 299 for (unsigned i = 0, e = TentativeDefinitions.size(); i != e; ++i) { 300 VarDecl *VD = TentativeDefinitions[i]->getActingDefinition(); 301 302 // If the tentative definition was completed, getActingDefinition() returns 303 // null. If we've already seen this variable before, insert()'s second 304 // return value is false. 305 if (VD == 0 || VD->isInvalidDecl() || !Seen.insert(VD)) 306 continue; 307 308 if (const IncompleteArrayType *ArrayT 309 = Context.getAsIncompleteArrayType(VD->getType())) { 310 if (RequireCompleteType(VD->getLocation(), 311 ArrayT->getElementType(), 312 diag::err_tentative_def_incomplete_type_arr)) { 313 VD->setInvalidDecl(); 314 continue; 315 } 316 317 // Set the length of the array to 1 (C99 6.9.2p5). 318 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array); 319 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true); 320 QualType T = Context.getConstantArrayType(ArrayT->getElementType(), 321 One, ArrayType::Normal, 0); 322 VD->setType(T); 323 } else if (RequireCompleteType(VD->getLocation(), VD->getType(), 324 diag::err_tentative_def_incomplete_type)) 325 VD->setInvalidDecl(); 326 327 // Notify the consumer that we've completed a tentative definition. 328 if (!VD->isInvalidDecl()) 329 Consumer.CompleteTentativeDefinition(VD); 330 331 } 332 333 // Output warning for unused file scoped decls. 334 for (std::vector<const DeclaratorDecl*>::iterator 335 I = UnusedFileScopedDecls.begin(), 336 E = UnusedFileScopedDecls.end(); I != E; ++I) { 337 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) 338 Diag(FD->getLocation(), diag::warn_unused_function) << FD->getDeclName(); 339 else 340 Diag((*I)->getLocation(), diag::warn_unused_variable) 341 << cast<VarDecl>(*I)->getDeclName(); 342 } 343} 344 345 346//===----------------------------------------------------------------------===// 347// Helper functions. 348//===----------------------------------------------------------------------===// 349 350DeclContext *Sema::getFunctionLevelDeclContext() { 351 DeclContext *DC = CurContext; 352 353 while (isa<BlockDecl>(DC) || isa<EnumDecl>(DC)) 354 DC = DC->getParent(); 355 356 return DC; 357} 358 359/// getCurFunctionDecl - If inside of a function body, this returns a pointer 360/// to the function decl for the function being parsed. If we're currently 361/// in a 'block', this returns the containing context. 362FunctionDecl *Sema::getCurFunctionDecl() { 363 DeclContext *DC = getFunctionLevelDeclContext(); 364 return dyn_cast<FunctionDecl>(DC); 365} 366 367ObjCMethodDecl *Sema::getCurMethodDecl() { 368 DeclContext *DC = getFunctionLevelDeclContext(); 369 return dyn_cast<ObjCMethodDecl>(DC); 370} 371 372NamedDecl *Sema::getCurFunctionOrMethodDecl() { 373 DeclContext *DC = getFunctionLevelDeclContext(); 374 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC)) 375 return cast<NamedDecl>(DC); 376 return 0; 377} 378 379Sema::SemaDiagnosticBuilder::~SemaDiagnosticBuilder() { 380 if (!this->Emit()) 381 return; 382 383 // If this is not a note, and we're in a template instantiation 384 // that is different from the last template instantiation where 385 // we emitted an error, print a template instantiation 386 // backtrace. 387 if (!SemaRef.Diags.isBuiltinNote(DiagID) && 388 !SemaRef.ActiveTemplateInstantiations.empty() && 389 SemaRef.ActiveTemplateInstantiations.back() 390 != SemaRef.LastTemplateInstantiationErrorContext) { 391 SemaRef.PrintInstantiationStack(); 392 SemaRef.LastTemplateInstantiationErrorContext 393 = SemaRef.ActiveTemplateInstantiations.back(); 394 } 395} 396 397Sema::SemaDiagnosticBuilder Sema::Diag(SourceLocation Loc, unsigned DiagID) { 398 if (isSFINAEContext()) { 399 switch (Diagnostic::getDiagnosticSFINAEResponse(DiagID)) { 400 case Diagnostic::SFINAE_Report: 401 // Fall through; we'll report the diagnostic below. 402 break; 403 404 case Diagnostic::SFINAE_SubstitutionFailure: 405 // Count this failure so that we know that template argument deduction 406 // has failed. 407 ++NumSFINAEErrors; 408 // Fall through 409 410 case Diagnostic::SFINAE_Suppress: 411 // Suppress this diagnostic. 412 Diags.setLastDiagnosticIgnored(); 413 return SemaDiagnosticBuilder(*this); 414 } 415 } 416 417 DiagnosticBuilder DB = Diags.Report(FullSourceLoc(Loc, SourceMgr), DiagID); 418 return SemaDiagnosticBuilder(DB, *this, DiagID); 419} 420 421Sema::SemaDiagnosticBuilder 422Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { 423 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID())); 424 PD.Emit(Builder); 425 426 return Builder; 427} 428 429/// \brief Determines the active Scope associated with the given declaration 430/// context. 431/// 432/// This routine maps a declaration context to the active Scope object that 433/// represents that declaration context in the parser. It is typically used 434/// from "scope-less" code (e.g., template instantiation, lazy creation of 435/// declarations) that injects a name for name-lookup purposes and, therefore, 436/// must update the Scope. 437/// 438/// \returns The scope corresponding to the given declaraion context, or NULL 439/// if no such scope is open. 440Scope *Sema::getScopeForContext(DeclContext *Ctx) { 441 442 if (!Ctx) 443 return 0; 444 445 Ctx = Ctx->getPrimaryContext(); 446 for (Scope *S = getCurScope(); S; S = S->getParent()) { 447 // Ignore scopes that cannot have declarations. This is important for 448 // out-of-line definitions of static class members. 449 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) 450 if (DeclContext *Entity = static_cast<DeclContext *> (S->getEntity())) 451 if (Ctx == Entity->getPrimaryContext()) 452 return S; 453 } 454 455 return 0; 456} 457 458/// \brief Enter a new function scope 459void Sema::PushFunctionScope() { 460 if (FunctionScopes.empty()) { 461 // Use the "top" function scope rather than having to allocate memory for 462 // a new scope. 463 TopFunctionScope.Clear(getDiagnostics().getNumErrors()); 464 FunctionScopes.push_back(&TopFunctionScope); 465 return; 466 } 467 468 FunctionScopes.push_back( 469 new FunctionScopeInfo(getDiagnostics().getNumErrors())); 470} 471 472void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) { 473 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics().getNumErrors(), 474 BlockScope, Block)); 475} 476 477void Sema::PopFunctionOrBlockScope() { 478 if (FunctionScopes.back() != &TopFunctionScope) 479 delete FunctionScopes.back(); 480 else 481 TopFunctionScope.Clear(getDiagnostics().getNumErrors()); 482 483 FunctionScopes.pop_back(); 484} 485 486/// \brief Determine whether any errors occurred within this function/method/ 487/// block. 488bool Sema::hasAnyErrorsInThisFunction() const { 489 unsigned NumErrors = TopFunctionScope.NumErrorsAtStartOfFunction; 490 if (!FunctionScopes.empty()) 491 NumErrors = FunctionScopes.back()->NumErrorsAtStartOfFunction; 492 return NumErrors != getDiagnostics().getNumErrors(); 493} 494 495BlockScopeInfo *Sema::getCurBlock() { 496 if (FunctionScopes.empty()) 497 return 0; 498 499 return dyn_cast<BlockScopeInfo>(FunctionScopes.back()); 500} 501 502// Pin this vtable to this file. 503ExternalSemaSource::~ExternalSemaSource() {} 504