1 //===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the actions class which performs semantic analysis and 10 // builds an AST out of a parse stream. 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "UsedDeclVisitor.h" 15 #include "clang/AST/ASTContext.h" 16 #include "clang/AST/ASTDiagnostic.h" 17 #include "clang/AST/DeclCXX.h" 18 #include "clang/AST/DeclFriend.h" 19 #include "clang/AST/DeclObjC.h" 20 #include "clang/AST/Expr.h" 21 #include "clang/AST/ExprCXX.h" 22 #include "clang/AST/PrettyDeclStackTrace.h" 23 #include "clang/AST/StmtCXX.h" 24 #include "clang/Basic/DiagnosticOptions.h" 25 #include "clang/Basic/PartialDiagnostic.h" 26 #include "clang/Basic/SourceManager.h" 27 #include "clang/Basic/Stack.h" 28 #include "clang/Basic/TargetInfo.h" 29 #include "clang/Lex/HeaderSearch.h" 30 #include "clang/Lex/Preprocessor.h" 31 #include "clang/Sema/CXXFieldCollector.h" 32 #include "clang/Sema/DelayedDiagnostic.h" 33 #include "clang/Sema/ExternalSemaSource.h" 34 #include "clang/Sema/Initialization.h" 35 #include "clang/Sema/MultiplexExternalSemaSource.h" 36 #include "clang/Sema/ObjCMethodList.h" 37 #include "clang/Sema/Scope.h" 38 #include "clang/Sema/ScopeInfo.h" 39 #include "clang/Sema/SemaConsumer.h" 40 #include "clang/Sema/SemaInternal.h" 41 #include "clang/Sema/TemplateDeduction.h" 42 #include "clang/Sema/TemplateInstCallback.h" 43 #include "clang/Sema/TypoCorrection.h" 44 #include "llvm/ADT/DenseMap.h" 45 #include "llvm/ADT/SmallSet.h" 46 #include "llvm/Support/TimeProfiler.h" 47 48 using namespace clang; 49 using namespace sema; 50 51 SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) { 52 return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts); 53 } 54 55 ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); } 56 57 IdentifierInfo * 58 Sema::InventAbbreviatedTemplateParameterTypeName(IdentifierInfo *ParamName, 59 unsigned int Index) { 60 std::string InventedName; 61 llvm::raw_string_ostream OS(InventedName); 62 63 if (!ParamName) 64 OS << "auto:" << Index + 1; 65 else 66 OS << ParamName->getName() << ":auto"; 67 68 OS.flush(); 69 return &Context.Idents.get(OS.str()); 70 } 71 72 PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context, 73 const Preprocessor &PP) { 74 PrintingPolicy Policy = Context.getPrintingPolicy(); 75 // In diagnostics, we print _Bool as bool if the latter is defined as the 76 // former. 77 Policy.Bool = Context.getLangOpts().Bool; 78 if (!Policy.Bool) { 79 if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) { 80 Policy.Bool = BoolMacro->isObjectLike() && 81 BoolMacro->getNumTokens() == 1 && 82 BoolMacro->getReplacementToken(0).is(tok::kw__Bool); 83 } 84 } 85 86 return Policy; 87 } 88 89 void Sema::ActOnTranslationUnitScope(Scope *S) { 90 TUScope = S; 91 PushDeclContext(S, Context.getTranslationUnitDecl()); 92 } 93 94 namespace clang { 95 namespace sema { 96 97 class SemaPPCallbacks : public PPCallbacks { 98 Sema *S = nullptr; 99 llvm::SmallVector<SourceLocation, 8> IncludeStack; 100 101 public: 102 void set(Sema &S) { this->S = &S; } 103 104 void reset() { S = nullptr; } 105 106 virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason, 107 SrcMgr::CharacteristicKind FileType, 108 FileID PrevFID) override { 109 if (!S) 110 return; 111 switch (Reason) { 112 case EnterFile: { 113 SourceManager &SM = S->getSourceManager(); 114 SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc)); 115 if (IncludeLoc.isValid()) { 116 if (llvm::timeTraceProfilerEnabled()) { 117 const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc)); 118 llvm::timeTraceProfilerBegin( 119 "Source", FE != nullptr ? FE->getName() : StringRef("<unknown>")); 120 } 121 122 IncludeStack.push_back(IncludeLoc); 123 S->DiagnoseNonDefaultPragmaPack( 124 Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc); 125 } 126 break; 127 } 128 case ExitFile: 129 if (!IncludeStack.empty()) { 130 if (llvm::timeTraceProfilerEnabled()) 131 llvm::timeTraceProfilerEnd(); 132 133 S->DiagnoseNonDefaultPragmaPack( 134 Sema::PragmaPackDiagnoseKind::ChangedStateAtExit, 135 IncludeStack.pop_back_val()); 136 } 137 break; 138 default: 139 break; 140 } 141 } 142 }; 143 144 } // end namespace sema 145 } // end namespace clang 146 147 const unsigned Sema::MaxAlignmentExponent; 148 const unsigned Sema::MaximumAlignment; 149 150 Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer, 151 TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter) 152 : ExternalSource(nullptr), isMultiplexExternalSource(false), 153 CurFPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp), 154 Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()), 155 SourceMgr(PP.getSourceManager()), CollectStats(false), 156 CodeCompleter(CodeCompleter), CurContext(nullptr), 157 OriginalLexicalContext(nullptr), MSStructPragmaOn(false), 158 MSPointerToMemberRepresentationMethod( 159 LangOpts.getMSPointerToMemberRepresentationMethod()), 160 VtorDispStack(LangOpts.getVtorDispMode()), PackStack(0), 161 DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr), 162 CodeSegStack(nullptr), FpPragmaStack(0xffffffff), CurInitSeg(nullptr), 163 VisContext(nullptr), PragmaAttributeCurrentTargetDecl(nullptr), 164 IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr), 165 LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp), 166 StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr), 167 StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr), 168 MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr), 169 NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr), 170 ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr), 171 ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr), 172 DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false), 173 TUKind(TUKind), NumSFINAEErrors(0), 174 FullyCheckedComparisonCategories( 175 static_cast<unsigned>(ComparisonCategoryType::Last) + 1), 176 SatisfactionCache(Context), AccessCheckingSFINAE(false), 177 InNonInstantiationSFINAEContext(false), NonInstantiationEntries(0), 178 ArgumentPackSubstitutionIndex(-1), CurrentInstantiationScope(nullptr), 179 DisableTypoCorrection(false), TyposCorrected(0), AnalysisWarnings(*this), 180 ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr), 181 CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) { 182 TUScope = nullptr; 183 isConstantEvaluatedOverride = false; 184 185 LoadedExternalKnownNamespaces = false; 186 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I) 187 NSNumberLiteralMethods[I] = nullptr; 188 189 if (getLangOpts().ObjC) 190 NSAPIObj.reset(new NSAPI(Context)); 191 192 if (getLangOpts().CPlusPlus) 193 FieldCollector.reset(new CXXFieldCollector()); 194 195 // Tell diagnostics how to render things from the AST library. 196 Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context); 197 198 ExprEvalContexts.emplace_back( 199 ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{}, 200 nullptr, ExpressionEvaluationContextRecord::EK_Other); 201 202 // Initialization of data sharing attributes stack for OpenMP 203 InitDataSharingAttributesStack(); 204 205 std::unique_ptr<sema::SemaPPCallbacks> Callbacks = 206 std::make_unique<sema::SemaPPCallbacks>(); 207 SemaPPCallbackHandler = Callbacks.get(); 208 PP.addPPCallbacks(std::move(Callbacks)); 209 SemaPPCallbackHandler->set(*this); 210 } 211 212 // Anchor Sema's type info to this TU. 213 void Sema::anchor() {} 214 215 void Sema::addImplicitTypedef(StringRef Name, QualType T) { 216 DeclarationName DN = &Context.Idents.get(Name); 217 if (IdResolver.begin(DN) == IdResolver.end()) 218 PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope); 219 } 220 221 void Sema::Initialize() { 222 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer)) 223 SC->InitializeSema(*this); 224 225 // Tell the external Sema source about this Sema object. 226 if (ExternalSemaSource *ExternalSema 227 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource())) 228 ExternalSema->InitializeSema(*this); 229 230 // This needs to happen after ExternalSemaSource::InitializeSema(this) or we 231 // will not be able to merge any duplicate __va_list_tag decls correctly. 232 VAListTagName = PP.getIdentifierInfo("__va_list_tag"); 233 234 if (!TUScope) 235 return; 236 237 // Initialize predefined 128-bit integer types, if needed. 238 if (Context.getTargetInfo().hasInt128Type()) { 239 // If either of the 128-bit integer types are unavailable to name lookup, 240 // define them now. 241 DeclarationName Int128 = &Context.Idents.get("__int128_t"); 242 if (IdResolver.begin(Int128) == IdResolver.end()) 243 PushOnScopeChains(Context.getInt128Decl(), TUScope); 244 245 DeclarationName UInt128 = &Context.Idents.get("__uint128_t"); 246 if (IdResolver.begin(UInt128) == IdResolver.end()) 247 PushOnScopeChains(Context.getUInt128Decl(), TUScope); 248 } 249 250 251 // Initialize predefined Objective-C types: 252 if (getLangOpts().ObjC) { 253 // If 'SEL' does not yet refer to any declarations, make it refer to the 254 // predefined 'SEL'. 255 DeclarationName SEL = &Context.Idents.get("SEL"); 256 if (IdResolver.begin(SEL) == IdResolver.end()) 257 PushOnScopeChains(Context.getObjCSelDecl(), TUScope); 258 259 // If 'id' does not yet refer to any declarations, make it refer to the 260 // predefined 'id'. 261 DeclarationName Id = &Context.Idents.get("id"); 262 if (IdResolver.begin(Id) == IdResolver.end()) 263 PushOnScopeChains(Context.getObjCIdDecl(), TUScope); 264 265 // Create the built-in typedef for 'Class'. 266 DeclarationName Class = &Context.Idents.get("Class"); 267 if (IdResolver.begin(Class) == IdResolver.end()) 268 PushOnScopeChains(Context.getObjCClassDecl(), TUScope); 269 270 // Create the built-in forward declaratino for 'Protocol'. 271 DeclarationName Protocol = &Context.Idents.get("Protocol"); 272 if (IdResolver.begin(Protocol) == IdResolver.end()) 273 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope); 274 } 275 276 // Create the internal type for the *StringMakeConstantString builtins. 277 DeclarationName ConstantString = &Context.Idents.get("__NSConstantString"); 278 if (IdResolver.begin(ConstantString) == IdResolver.end()) 279 PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope); 280 281 // Initialize Microsoft "predefined C++ types". 282 if (getLangOpts().MSVCCompat) { 283 if (getLangOpts().CPlusPlus && 284 IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end()) 285 PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class), 286 TUScope); 287 288 addImplicitTypedef("size_t", Context.getSizeType()); 289 } 290 291 // Initialize predefined OpenCL types and supported extensions and (optional) 292 // core features. 293 if (getLangOpts().OpenCL) { 294 getOpenCLOptions().addSupport( 295 Context.getTargetInfo().getSupportedOpenCLOpts()); 296 getOpenCLOptions().enableSupportedCore(getLangOpts()); 297 addImplicitTypedef("sampler_t", Context.OCLSamplerTy); 298 addImplicitTypedef("event_t", Context.OCLEventTy); 299 if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) { 300 addImplicitTypedef("clk_event_t", Context.OCLClkEventTy); 301 addImplicitTypedef("queue_t", Context.OCLQueueTy); 302 addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy); 303 addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy)); 304 addImplicitTypedef("atomic_uint", 305 Context.getAtomicType(Context.UnsignedIntTy)); 306 auto AtomicLongT = Context.getAtomicType(Context.LongTy); 307 addImplicitTypedef("atomic_long", AtomicLongT); 308 auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy); 309 addImplicitTypedef("atomic_ulong", AtomicULongT); 310 addImplicitTypedef("atomic_float", 311 Context.getAtomicType(Context.FloatTy)); 312 auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy); 313 addImplicitTypedef("atomic_double", AtomicDoubleT); 314 // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as 315 // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide. 316 addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy)); 317 auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType()); 318 addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT); 319 auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType()); 320 addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT); 321 auto AtomicSizeT = Context.getAtomicType(Context.getSizeType()); 322 addImplicitTypedef("atomic_size_t", AtomicSizeT); 323 auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType()); 324 addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT); 325 326 // OpenCL v2.0 s6.13.11.6: 327 // - The atomic_long and atomic_ulong types are supported if the 328 // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics 329 // extensions are supported. 330 // - The atomic_double type is only supported if double precision 331 // is supported and the cl_khr_int64_base_atomics and 332 // cl_khr_int64_extended_atomics extensions are supported. 333 // - If the device address space is 64-bits, the data types 334 // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and 335 // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and 336 // cl_khr_int64_extended_atomics extensions are supported. 337 std::vector<QualType> Atomic64BitTypes; 338 Atomic64BitTypes.push_back(AtomicLongT); 339 Atomic64BitTypes.push_back(AtomicULongT); 340 Atomic64BitTypes.push_back(AtomicDoubleT); 341 if (Context.getTypeSize(AtomicSizeT) == 64) { 342 Atomic64BitTypes.push_back(AtomicSizeT); 343 Atomic64BitTypes.push_back(AtomicIntPtrT); 344 Atomic64BitTypes.push_back(AtomicUIntPtrT); 345 Atomic64BitTypes.push_back(AtomicPtrDiffT); 346 } 347 for (auto &I : Atomic64BitTypes) 348 setOpenCLExtensionForType(I, 349 "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics"); 350 351 setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64"); 352 } 353 354 setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64"); 355 356 #define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \ 357 setOpenCLExtensionForType(Context.Id, Ext); 358 #include "clang/Basic/OpenCLImageTypes.def" 359 #define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \ 360 addImplicitTypedef(#ExtType, Context.Id##Ty); \ 361 setOpenCLExtensionForType(Context.Id##Ty, #Ext); 362 #include "clang/Basic/OpenCLExtensionTypes.def" 363 } 364 365 if (Context.getTargetInfo().hasAArch64SVETypes()) { 366 #define SVE_TYPE(Name, Id, SingletonId) \ 367 addImplicitTypedef(Name, Context.SingletonId); 368 #include "clang/Basic/AArch64SVEACLETypes.def" 369 } 370 371 if (Context.getTargetInfo().hasBuiltinMSVaList()) { 372 DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list"); 373 if (IdResolver.begin(MSVaList) == IdResolver.end()) 374 PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope); 375 } 376 377 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list"); 378 if (IdResolver.begin(BuiltinVaList) == IdResolver.end()) 379 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope); 380 } 381 382 Sema::~Sema() { 383 if (VisContext) FreeVisContext(); 384 385 // Kill all the active scopes. 386 for (sema::FunctionScopeInfo *FSI : FunctionScopes) 387 delete FSI; 388 389 // Tell the SemaConsumer to forget about us; we're going out of scope. 390 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer)) 391 SC->ForgetSema(); 392 393 // Detach from the external Sema source. 394 if (ExternalSemaSource *ExternalSema 395 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource())) 396 ExternalSema->ForgetSema(); 397 398 // If Sema's ExternalSource is the multiplexer - we own it. 399 if (isMultiplexExternalSource) 400 delete ExternalSource; 401 402 // Delete cached satisfactions. 403 std::vector<ConstraintSatisfaction *> Satisfactions; 404 Satisfactions.reserve(Satisfactions.size()); 405 for (auto &Node : SatisfactionCache) 406 Satisfactions.push_back(&Node); 407 for (auto *Node : Satisfactions) 408 delete Node; 409 410 threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache); 411 412 // Destroys data sharing attributes stack for OpenMP 413 DestroyDataSharingAttributesStack(); 414 415 // Detach from the PP callback handler which outlives Sema since it's owned 416 // by the preprocessor. 417 SemaPPCallbackHandler->reset(); 418 } 419 420 void Sema::warnStackExhausted(SourceLocation Loc) { 421 // Only warn about this once. 422 if (!WarnedStackExhausted) { 423 Diag(Loc, diag::warn_stack_exhausted); 424 WarnedStackExhausted = true; 425 } 426 } 427 428 void Sema::runWithSufficientStackSpace(SourceLocation Loc, 429 llvm::function_ref<void()> Fn) { 430 clang::runWithSufficientStackSpace([&] { warnStackExhausted(Loc); }, Fn); 431 } 432 433 /// makeUnavailableInSystemHeader - There is an error in the current 434 /// context. If we're still in a system header, and we can plausibly 435 /// make the relevant declaration unavailable instead of erroring, do 436 /// so and return true. 437 bool Sema::makeUnavailableInSystemHeader(SourceLocation loc, 438 UnavailableAttr::ImplicitReason reason) { 439 // If we're not in a function, it's an error. 440 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext); 441 if (!fn) return false; 442 443 // If we're in template instantiation, it's an error. 444 if (inTemplateInstantiation()) 445 return false; 446 447 // If that function's not in a system header, it's an error. 448 if (!Context.getSourceManager().isInSystemHeader(loc)) 449 return false; 450 451 // If the function is already unavailable, it's not an error. 452 if (fn->hasAttr<UnavailableAttr>()) return true; 453 454 fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc)); 455 return true; 456 } 457 458 ASTMutationListener *Sema::getASTMutationListener() const { 459 return getASTConsumer().GetASTMutationListener(); 460 } 461 462 ///Registers an external source. If an external source already exists, 463 /// creates a multiplex external source and appends to it. 464 /// 465 ///\param[in] E - A non-null external sema source. 466 /// 467 void Sema::addExternalSource(ExternalSemaSource *E) { 468 assert(E && "Cannot use with NULL ptr"); 469 470 if (!ExternalSource) { 471 ExternalSource = E; 472 return; 473 } 474 475 if (isMultiplexExternalSource) 476 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E); 477 else { 478 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E); 479 isMultiplexExternalSource = true; 480 } 481 } 482 483 /// Print out statistics about the semantic analysis. 484 void Sema::PrintStats() const { 485 llvm::errs() << "\n*** Semantic Analysis Stats:\n"; 486 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n"; 487 488 BumpAlloc.PrintStats(); 489 AnalysisWarnings.PrintStats(); 490 } 491 492 void Sema::diagnoseNullableToNonnullConversion(QualType DstType, 493 QualType SrcType, 494 SourceLocation Loc) { 495 Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context); 496 if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable) 497 return; 498 499 Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context); 500 if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull) 501 return; 502 503 Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType; 504 } 505 506 void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) { 507 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant, 508 E->getBeginLoc())) 509 return; 510 // nullptr only exists from C++11 on, so don't warn on its absence earlier. 511 if (!getLangOpts().CPlusPlus11) 512 return; 513 514 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer) 515 return; 516 if (E->IgnoreParenImpCasts()->getType()->isNullPtrType()) 517 return; 518 519 // If it is a macro from system header, and if the macro name is not "NULL", 520 // do not warn. 521 SourceLocation MaybeMacroLoc = E->getBeginLoc(); 522 if (Diags.getSuppressSystemWarnings() && 523 SourceMgr.isInSystemMacro(MaybeMacroLoc) && 524 !findMacroSpelling(MaybeMacroLoc, "NULL")) 525 return; 526 527 Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant) 528 << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr"); 529 } 530 531 /// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast. 532 /// If there is already an implicit cast, merge into the existing one. 533 /// The result is of the given category. 534 ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty, 535 CastKind Kind, ExprValueKind VK, 536 const CXXCastPath *BasePath, 537 CheckedConversionKind CCK) { 538 #ifndef NDEBUG 539 if (VK == VK_RValue && !E->isRValue()) { 540 switch (Kind) { 541 default: 542 llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast " 543 "kind"); 544 case CK_Dependent: 545 case CK_LValueToRValue: 546 case CK_ArrayToPointerDecay: 547 case CK_FunctionToPointerDecay: 548 case CK_ToVoid: 549 case CK_NonAtomicToAtomic: 550 break; 551 } 552 } 553 assert((VK == VK_RValue || Kind == CK_Dependent || !E->isRValue()) && 554 "can't cast rvalue to lvalue"); 555 #endif 556 557 diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc()); 558 diagnoseZeroToNullptrConversion(Kind, E); 559 560 QualType ExprTy = Context.getCanonicalType(E->getType()); 561 QualType TypeTy = Context.getCanonicalType(Ty); 562 563 if (ExprTy == TypeTy) 564 return E; 565 566 // C++1z [conv.array]: The temporary materialization conversion is applied. 567 // We also use this to fuel C++ DR1213, which applies to C++11 onwards. 568 if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus && 569 E->getValueKind() == VK_RValue) { 570 // The temporary is an lvalue in C++98 and an xvalue otherwise. 571 ExprResult Materialized = CreateMaterializeTemporaryExpr( 572 E->getType(), E, !getLangOpts().CPlusPlus11); 573 if (Materialized.isInvalid()) 574 return ExprError(); 575 E = Materialized.get(); 576 } 577 578 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) { 579 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) { 580 ImpCast->setType(Ty); 581 ImpCast->setValueKind(VK); 582 return E; 583 } 584 } 585 586 return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK); 587 } 588 589 /// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding 590 /// to the conversion from scalar type ScalarTy to the Boolean type. 591 CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) { 592 switch (ScalarTy->getScalarTypeKind()) { 593 case Type::STK_Bool: return CK_NoOp; 594 case Type::STK_CPointer: return CK_PointerToBoolean; 595 case Type::STK_BlockPointer: return CK_PointerToBoolean; 596 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean; 597 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean; 598 case Type::STK_Integral: return CK_IntegralToBoolean; 599 case Type::STK_Floating: return CK_FloatingToBoolean; 600 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean; 601 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean; 602 case Type::STK_FixedPoint: return CK_FixedPointToBoolean; 603 } 604 llvm_unreachable("unknown scalar type kind"); 605 } 606 607 /// Used to prune the decls of Sema's UnusedFileScopedDecls vector. 608 static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) { 609 if (D->getMostRecentDecl()->isUsed()) 610 return true; 611 612 if (D->isExternallyVisible()) 613 return true; 614 615 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 616 // If this is a function template and none of its specializations is used, 617 // we should warn. 618 if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate()) 619 for (const auto *Spec : Template->specializations()) 620 if (ShouldRemoveFromUnused(SemaRef, Spec)) 621 return true; 622 623 // UnusedFileScopedDecls stores the first declaration. 624 // The declaration may have become definition so check again. 625 const FunctionDecl *DeclToCheck; 626 if (FD->hasBody(DeclToCheck)) 627 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); 628 629 // Later redecls may add new information resulting in not having to warn, 630 // so check again. 631 DeclToCheck = FD->getMostRecentDecl(); 632 if (DeclToCheck != FD) 633 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); 634 } 635 636 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) { 637 // If a variable usable in constant expressions is referenced, 638 // don't warn if it isn't used: if the value of a variable is required 639 // for the computation of a constant expression, it doesn't make sense to 640 // warn even if the variable isn't odr-used. (isReferenced doesn't 641 // precisely reflect that, but it's a decent approximation.) 642 if (VD->isReferenced() && 643 VD->mightBeUsableInConstantExpressions(SemaRef->Context)) 644 return true; 645 646 if (VarTemplateDecl *Template = VD->getDescribedVarTemplate()) 647 // If this is a variable template and none of its specializations is used, 648 // we should warn. 649 for (const auto *Spec : Template->specializations()) 650 if (ShouldRemoveFromUnused(SemaRef, Spec)) 651 return true; 652 653 // UnusedFileScopedDecls stores the first declaration. 654 // The declaration may have become definition so check again. 655 const VarDecl *DeclToCheck = VD->getDefinition(); 656 if (DeclToCheck) 657 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); 658 659 // Later redecls may add new information resulting in not having to warn, 660 // so check again. 661 DeclToCheck = VD->getMostRecentDecl(); 662 if (DeclToCheck != VD) 663 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck); 664 } 665 666 return false; 667 } 668 669 static bool isFunctionOrVarDeclExternC(NamedDecl *ND) { 670 if (auto *FD = dyn_cast<FunctionDecl>(ND)) 671 return FD->isExternC(); 672 return cast<VarDecl>(ND)->isExternC(); 673 } 674 675 /// Determine whether ND is an external-linkage function or variable whose 676 /// type has no linkage. 677 bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) { 678 // Note: it's not quite enough to check whether VD has UniqueExternalLinkage, 679 // because we also want to catch the case where its type has VisibleNoLinkage, 680 // which does not affect the linkage of VD. 681 return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() && 682 !isExternalFormalLinkage(VD->getType()->getLinkage()) && 683 !isFunctionOrVarDeclExternC(VD); 684 } 685 686 /// Obtains a sorted list of functions and variables that are undefined but 687 /// ODR-used. 688 void Sema::getUndefinedButUsed( 689 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) { 690 for (const auto &UndefinedUse : UndefinedButUsed) { 691 NamedDecl *ND = UndefinedUse.first; 692 693 // Ignore attributes that have become invalid. 694 if (ND->isInvalidDecl()) continue; 695 696 // __attribute__((weakref)) is basically a definition. 697 if (ND->hasAttr<WeakRefAttr>()) continue; 698 699 if (isa<CXXDeductionGuideDecl>(ND)) 700 continue; 701 702 if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) { 703 // An exported function will always be emitted when defined, so even if 704 // the function is inline, it doesn't have to be emitted in this TU. An 705 // imported function implies that it has been exported somewhere else. 706 continue; 707 } 708 709 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { 710 if (FD->isDefined()) 711 continue; 712 if (FD->isExternallyVisible() && 713 !isExternalWithNoLinkageType(FD) && 714 !FD->getMostRecentDecl()->isInlined() && 715 !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>()) 716 continue; 717 if (FD->getBuiltinID()) 718 continue; 719 } else { 720 auto *VD = cast<VarDecl>(ND); 721 if (VD->hasDefinition() != VarDecl::DeclarationOnly) 722 continue; 723 if (VD->isExternallyVisible() && 724 !isExternalWithNoLinkageType(VD) && 725 !VD->getMostRecentDecl()->isInline() && 726 !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>()) 727 continue; 728 729 // Skip VarDecls that lack formal definitions but which we know are in 730 // fact defined somewhere. 731 if (VD->isKnownToBeDefined()) 732 continue; 733 } 734 735 Undefined.push_back(std::make_pair(ND, UndefinedUse.second)); 736 } 737 } 738 739 /// checkUndefinedButUsed - Check for undefined objects with internal linkage 740 /// or that are inline. 741 static void checkUndefinedButUsed(Sema &S) { 742 if (S.UndefinedButUsed.empty()) return; 743 744 // Collect all the still-undefined entities with internal linkage. 745 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined; 746 S.getUndefinedButUsed(Undefined); 747 if (Undefined.empty()) return; 748 749 for (auto Undef : Undefined) { 750 ValueDecl *VD = cast<ValueDecl>(Undef.first); 751 SourceLocation UseLoc = Undef.second; 752 753 if (S.isExternalWithNoLinkageType(VD)) { 754 // C++ [basic.link]p8: 755 // A type without linkage shall not be used as the type of a variable 756 // or function with external linkage unless 757 // -- the entity has C language linkage 758 // -- the entity is not odr-used or is defined in the same TU 759 // 760 // As an extension, accept this in cases where the type is externally 761 // visible, since the function or variable actually can be defined in 762 // another translation unit in that case. 763 S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage()) 764 ? diag::ext_undefined_internal_type 765 : diag::err_undefined_internal_type) 766 << isa<VarDecl>(VD) << VD; 767 } else if (!VD->isExternallyVisible()) { 768 // FIXME: We can promote this to an error. The function or variable can't 769 // be defined anywhere else, so the program must necessarily violate the 770 // one definition rule. 771 S.Diag(VD->getLocation(), diag::warn_undefined_internal) 772 << isa<VarDecl>(VD) << VD; 773 } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) { 774 (void)FD; 775 assert(FD->getMostRecentDecl()->isInlined() && 776 "used object requires definition but isn't inline or internal?"); 777 // FIXME: This is ill-formed; we should reject. 778 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD; 779 } else { 780 assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() && 781 "used var requires definition but isn't inline or internal?"); 782 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD; 783 } 784 if (UseLoc.isValid()) 785 S.Diag(UseLoc, diag::note_used_here); 786 } 787 788 S.UndefinedButUsed.clear(); 789 } 790 791 void Sema::LoadExternalWeakUndeclaredIdentifiers() { 792 if (!ExternalSource) 793 return; 794 795 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs; 796 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs); 797 for (auto &WeakID : WeakIDs) 798 WeakUndeclaredIdentifiers.insert(WeakID); 799 } 800 801 802 typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap; 803 804 /// Returns true, if all methods and nested classes of the given 805 /// CXXRecordDecl are defined in this translation unit. 806 /// 807 /// Should only be called from ActOnEndOfTranslationUnit so that all 808 /// definitions are actually read. 809 static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD, 810 RecordCompleteMap &MNCComplete) { 811 RecordCompleteMap::iterator Cache = MNCComplete.find(RD); 812 if (Cache != MNCComplete.end()) 813 return Cache->second; 814 if (!RD->isCompleteDefinition()) 815 return false; 816 bool Complete = true; 817 for (DeclContext::decl_iterator I = RD->decls_begin(), 818 E = RD->decls_end(); 819 I != E && Complete; ++I) { 820 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I)) 821 Complete = M->isDefined() || M->isDefaulted() || 822 (M->isPure() && !isa<CXXDestructorDecl>(M)); 823 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I)) 824 // If the template function is marked as late template parsed at this 825 // point, it has not been instantiated and therefore we have not 826 // performed semantic analysis on it yet, so we cannot know if the type 827 // can be considered complete. 828 Complete = !F->getTemplatedDecl()->isLateTemplateParsed() && 829 F->getTemplatedDecl()->isDefined(); 830 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) { 831 if (R->isInjectedClassName()) 832 continue; 833 if (R->hasDefinition()) 834 Complete = MethodsAndNestedClassesComplete(R->getDefinition(), 835 MNCComplete); 836 else 837 Complete = false; 838 } 839 } 840 MNCComplete[RD] = Complete; 841 return Complete; 842 } 843 844 /// Returns true, if the given CXXRecordDecl is fully defined in this 845 /// translation unit, i.e. all methods are defined or pure virtual and all 846 /// friends, friend functions and nested classes are fully defined in this 847 /// translation unit. 848 /// 849 /// Should only be called from ActOnEndOfTranslationUnit so that all 850 /// definitions are actually read. 851 static bool IsRecordFullyDefined(const CXXRecordDecl *RD, 852 RecordCompleteMap &RecordsComplete, 853 RecordCompleteMap &MNCComplete) { 854 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD); 855 if (Cache != RecordsComplete.end()) 856 return Cache->second; 857 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete); 858 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(), 859 E = RD->friend_end(); 860 I != E && Complete; ++I) { 861 // Check if friend classes and methods are complete. 862 if (TypeSourceInfo *TSI = (*I)->getFriendType()) { 863 // Friend classes are available as the TypeSourceInfo of the FriendDecl. 864 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl()) 865 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete); 866 else 867 Complete = false; 868 } else { 869 // Friend functions are available through the NamedDecl of FriendDecl. 870 if (const FunctionDecl *FD = 871 dyn_cast<FunctionDecl>((*I)->getFriendDecl())) 872 Complete = FD->isDefined(); 873 else 874 // This is a template friend, give up. 875 Complete = false; 876 } 877 } 878 RecordsComplete[RD] = Complete; 879 return Complete; 880 } 881 882 void Sema::emitAndClearUnusedLocalTypedefWarnings() { 883 if (ExternalSource) 884 ExternalSource->ReadUnusedLocalTypedefNameCandidates( 885 UnusedLocalTypedefNameCandidates); 886 for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) { 887 if (TD->isReferenced()) 888 continue; 889 Diag(TD->getLocation(), diag::warn_unused_local_typedef) 890 << isa<TypeAliasDecl>(TD) << TD->getDeclName(); 891 } 892 UnusedLocalTypedefNameCandidates.clear(); 893 } 894 895 /// This is called before the very first declaration in the translation unit 896 /// is parsed. Note that the ASTContext may have already injected some 897 /// declarations. 898 void Sema::ActOnStartOfTranslationUnit() { 899 if (getLangOpts().ModulesTS && 900 (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface || 901 getLangOpts().getCompilingModule() == LangOptions::CMK_None)) { 902 // We start in an implied global module fragment. 903 SourceLocation StartOfTU = 904 SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID()); 905 ActOnGlobalModuleFragmentDecl(StartOfTU); 906 ModuleScopes.back().ImplicitGlobalModuleFragment = true; 907 } 908 } 909 910 void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) { 911 // No explicit actions are required at the end of the global module fragment. 912 if (Kind == TUFragmentKind::Global) 913 return; 914 915 // Transfer late parsed template instantiations over to the pending template 916 // instantiation list. During normal compilation, the late template parser 917 // will be installed and instantiating these templates will succeed. 918 // 919 // If we are building a TU prefix for serialization, it is also safe to 920 // transfer these over, even though they are not parsed. The end of the TU 921 // should be outside of any eager template instantiation scope, so when this 922 // AST is deserialized, these templates will not be parsed until the end of 923 // the combined TU. 924 PendingInstantiations.insert(PendingInstantiations.end(), 925 LateParsedInstantiations.begin(), 926 LateParsedInstantiations.end()); 927 LateParsedInstantiations.clear(); 928 929 // If DefinedUsedVTables ends up marking any virtual member functions it 930 // might lead to more pending template instantiations, which we then need 931 // to instantiate. 932 DefineUsedVTables(); 933 934 // C++: Perform implicit template instantiations. 935 // 936 // FIXME: When we perform these implicit instantiations, we do not 937 // carefully keep track of the point of instantiation (C++ [temp.point]). 938 // This means that name lookup that occurs within the template 939 // instantiation will always happen at the end of the translation unit, 940 // so it will find some names that are not required to be found. This is 941 // valid, but we could do better by diagnosing if an instantiation uses a 942 // name that was not visible at its first point of instantiation. 943 if (ExternalSource) { 944 // Load pending instantiations from the external source. 945 SmallVector<PendingImplicitInstantiation, 4> Pending; 946 ExternalSource->ReadPendingInstantiations(Pending); 947 for (auto PII : Pending) 948 if (auto Func = dyn_cast<FunctionDecl>(PII.first)) 949 Func->setInstantiationIsPending(true); 950 PendingInstantiations.insert(PendingInstantiations.begin(), 951 Pending.begin(), Pending.end()); 952 } 953 954 { 955 llvm::TimeTraceScope TimeScope("PerformPendingInstantiations"); 956 PerformPendingInstantiations(); 957 } 958 959 emitDeferredDiags(); 960 961 assert(LateParsedInstantiations.empty() && 962 "end of TU template instantiation should not create more " 963 "late-parsed templates"); 964 965 // Report diagnostics for uncorrected delayed typos. Ideally all of them 966 // should have been corrected by that time, but it is very hard to cover all 967 // cases in practice. 968 for (const auto &Typo : DelayedTypos) { 969 // We pass an empty TypoCorrection to indicate no correction was performed. 970 Typo.second.DiagHandler(TypoCorrection()); 971 } 972 DelayedTypos.clear(); 973 } 974 975 /// ActOnEndOfTranslationUnit - This is called at the very end of the 976 /// translation unit when EOF is reached and all but the top-level scope is 977 /// popped. 978 void Sema::ActOnEndOfTranslationUnit() { 979 assert(DelayedDiagnostics.getCurrentPool() == nullptr 980 && "reached end of translation unit with a pool attached?"); 981 982 // If code completion is enabled, don't perform any end-of-translation-unit 983 // work. 984 if (PP.isCodeCompletionEnabled()) 985 return; 986 987 // Complete translation units and modules define vtables and perform implicit 988 // instantiations. PCH files do not. 989 if (TUKind != TU_Prefix) { 990 DiagnoseUseOfUnimplementedSelectors(); 991 992 ActOnEndOfTranslationUnitFragment( 993 !ModuleScopes.empty() && ModuleScopes.back().Module->Kind == 994 Module::PrivateModuleFragment 995 ? TUFragmentKind::Private 996 : TUFragmentKind::Normal); 997 998 if (LateTemplateParserCleanup) 999 LateTemplateParserCleanup(OpaqueParser); 1000 1001 CheckDelayedMemberExceptionSpecs(); 1002 } else { 1003 // If we are building a TU prefix for serialization, it is safe to transfer 1004 // these over, even though they are not parsed. The end of the TU should be 1005 // outside of any eager template instantiation scope, so when this AST is 1006 // deserialized, these templates will not be parsed until the end of the 1007 // combined TU. 1008 PendingInstantiations.insert(PendingInstantiations.end(), 1009 LateParsedInstantiations.begin(), 1010 LateParsedInstantiations.end()); 1011 LateParsedInstantiations.clear(); 1012 1013 if (LangOpts.PCHInstantiateTemplates) { 1014 llvm::TimeTraceScope TimeScope("PerformPendingInstantiations"); 1015 PerformPendingInstantiations(); 1016 } 1017 } 1018 1019 DiagnoseUnterminatedPragmaPack(); 1020 DiagnoseUnterminatedPragmaAttribute(); 1021 1022 // All delayed member exception specs should be checked or we end up accepting 1023 // incompatible declarations. 1024 assert(DelayedOverridingExceptionSpecChecks.empty()); 1025 assert(DelayedEquivalentExceptionSpecChecks.empty()); 1026 1027 // All dllexport classes should have been processed already. 1028 assert(DelayedDllExportClasses.empty()); 1029 assert(DelayedDllExportMemberFunctions.empty()); 1030 1031 // Remove file scoped decls that turned out to be used. 1032 UnusedFileScopedDecls.erase( 1033 std::remove_if(UnusedFileScopedDecls.begin(nullptr, true), 1034 UnusedFileScopedDecls.end(), 1035 [this](const DeclaratorDecl *DD) { 1036 return ShouldRemoveFromUnused(this, DD); 1037 }), 1038 UnusedFileScopedDecls.end()); 1039 1040 if (TUKind == TU_Prefix) { 1041 // Translation unit prefixes don't need any of the checking below. 1042 if (!PP.isIncrementalProcessingEnabled()) 1043 TUScope = nullptr; 1044 return; 1045 } 1046 1047 // Check for #pragma weak identifiers that were never declared 1048 LoadExternalWeakUndeclaredIdentifiers(); 1049 for (auto WeakID : WeakUndeclaredIdentifiers) { 1050 if (WeakID.second.getUsed()) 1051 continue; 1052 1053 Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(), 1054 LookupOrdinaryName); 1055 if (PrevDecl != nullptr && 1056 !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl))) 1057 Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type) 1058 << "'weak'" << ExpectedVariableOrFunction; 1059 else 1060 Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared) 1061 << WeakID.first; 1062 } 1063 1064 if (LangOpts.CPlusPlus11 && 1065 !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation())) 1066 CheckDelegatingCtorCycles(); 1067 1068 if (!Diags.hasErrorOccurred()) { 1069 if (ExternalSource) 1070 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed); 1071 checkUndefinedButUsed(*this); 1072 } 1073 1074 // A global-module-fragment is only permitted within a module unit. 1075 bool DiagnosedMissingModuleDeclaration = false; 1076 if (!ModuleScopes.empty() && 1077 ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment && 1078 !ModuleScopes.back().ImplicitGlobalModuleFragment) { 1079 Diag(ModuleScopes.back().BeginLoc, 1080 diag::err_module_declaration_missing_after_global_module_introducer); 1081 DiagnosedMissingModuleDeclaration = true; 1082 } 1083 1084 if (TUKind == TU_Module) { 1085 // If we are building a module interface unit, we need to have seen the 1086 // module declaration by now. 1087 if (getLangOpts().getCompilingModule() == 1088 LangOptions::CMK_ModuleInterface && 1089 (ModuleScopes.empty() || 1090 !ModuleScopes.back().Module->isModulePurview()) && 1091 !DiagnosedMissingModuleDeclaration) { 1092 // FIXME: Make a better guess as to where to put the module declaration. 1093 Diag(getSourceManager().getLocForStartOfFile( 1094 getSourceManager().getMainFileID()), 1095 diag::err_module_declaration_missing); 1096 } 1097 1098 // If we are building a module, resolve all of the exported declarations 1099 // now. 1100 if (Module *CurrentModule = PP.getCurrentModule()) { 1101 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap(); 1102 1103 SmallVector<Module *, 2> Stack; 1104 Stack.push_back(CurrentModule); 1105 while (!Stack.empty()) { 1106 Module *Mod = Stack.pop_back_val(); 1107 1108 // Resolve the exported declarations and conflicts. 1109 // FIXME: Actually complain, once we figure out how to teach the 1110 // diagnostic client to deal with complaints in the module map at this 1111 // point. 1112 ModMap.resolveExports(Mod, /*Complain=*/false); 1113 ModMap.resolveUses(Mod, /*Complain=*/false); 1114 ModMap.resolveConflicts(Mod, /*Complain=*/false); 1115 1116 // Queue the submodules, so their exports will also be resolved. 1117 Stack.append(Mod->submodule_begin(), Mod->submodule_end()); 1118 } 1119 } 1120 1121 // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for 1122 // modules when they are built, not every time they are used. 1123 emitAndClearUnusedLocalTypedefWarnings(); 1124 } 1125 1126 // C99 6.9.2p2: 1127 // A declaration of an identifier for an object that has file 1128 // scope without an initializer, and without a storage-class 1129 // specifier or with the storage-class specifier static, 1130 // constitutes a tentative definition. If a translation unit 1131 // contains one or more tentative definitions for an identifier, 1132 // and the translation unit contains no external definition for 1133 // that identifier, then the behavior is exactly as if the 1134 // translation unit contains a file scope declaration of that 1135 // identifier, with the composite type as of the end of the 1136 // translation unit, with an initializer equal to 0. 1137 llvm::SmallSet<VarDecl *, 32> Seen; 1138 for (TentativeDefinitionsType::iterator 1139 T = TentativeDefinitions.begin(ExternalSource), 1140 TEnd = TentativeDefinitions.end(); 1141 T != TEnd; ++T) { 1142 VarDecl *VD = (*T)->getActingDefinition(); 1143 1144 // If the tentative definition was completed, getActingDefinition() returns 1145 // null. If we've already seen this variable before, insert()'s second 1146 // return value is false. 1147 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second) 1148 continue; 1149 1150 if (const IncompleteArrayType *ArrayT 1151 = Context.getAsIncompleteArrayType(VD->getType())) { 1152 // Set the length of the array to 1 (C99 6.9.2p5). 1153 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array); 1154 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true); 1155 QualType T = Context.getConstantArrayType(ArrayT->getElementType(), One, 1156 nullptr, ArrayType::Normal, 0); 1157 VD->setType(T); 1158 } else if (RequireCompleteType(VD->getLocation(), VD->getType(), 1159 diag::err_tentative_def_incomplete_type)) 1160 VD->setInvalidDecl(); 1161 1162 // No initialization is performed for a tentative definition. 1163 CheckCompleteVariableDeclaration(VD); 1164 1165 // Notify the consumer that we've completed a tentative definition. 1166 if (!VD->isInvalidDecl()) 1167 Consumer.CompleteTentativeDefinition(VD); 1168 } 1169 1170 for (auto D : ExternalDeclarations) { 1171 if (!D || D->isInvalidDecl() || D->getPreviousDecl() || !D->isUsed()) 1172 continue; 1173 1174 Consumer.CompleteExternalDeclaration(D); 1175 } 1176 1177 // If there were errors, disable 'unused' warnings since they will mostly be 1178 // noise. Don't warn for a use from a module: either we should warn on all 1179 // file-scope declarations in modules or not at all, but whether the 1180 // declaration is used is immaterial. 1181 if (!Diags.hasErrorOccurred() && TUKind != TU_Module) { 1182 // Output warning for unused file scoped decls. 1183 for (UnusedFileScopedDeclsType::iterator 1184 I = UnusedFileScopedDecls.begin(ExternalSource), 1185 E = UnusedFileScopedDecls.end(); I != E; ++I) { 1186 if (ShouldRemoveFromUnused(this, *I)) 1187 continue; 1188 1189 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) { 1190 const FunctionDecl *DiagD; 1191 if (!FD->hasBody(DiagD)) 1192 DiagD = FD; 1193 if (DiagD->isDeleted()) 1194 continue; // Deleted functions are supposed to be unused. 1195 if (DiagD->isReferenced()) { 1196 if (isa<CXXMethodDecl>(DiagD)) 1197 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function) 1198 << DiagD->getDeclName(); 1199 else { 1200 if (FD->getStorageClass() == SC_Static && 1201 !FD->isInlineSpecified() && 1202 !SourceMgr.isInMainFile( 1203 SourceMgr.getExpansionLoc(FD->getLocation()))) 1204 Diag(DiagD->getLocation(), 1205 diag::warn_unneeded_static_internal_decl) 1206 << DiagD->getDeclName(); 1207 else 1208 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) 1209 << /*function*/0 << DiagD->getDeclName(); 1210 } 1211 } else { 1212 if (FD->getDescribedFunctionTemplate()) 1213 Diag(DiagD->getLocation(), diag::warn_unused_template) 1214 << /*function*/0 << DiagD->getDeclName(); 1215 else 1216 Diag(DiagD->getLocation(), 1217 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function 1218 : diag::warn_unused_function) 1219 << DiagD->getDeclName(); 1220 } 1221 } else { 1222 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition(); 1223 if (!DiagD) 1224 DiagD = cast<VarDecl>(*I); 1225 if (DiagD->isReferenced()) { 1226 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl) 1227 << /*variable*/1 << DiagD->getDeclName(); 1228 } else if (DiagD->getType().isConstQualified()) { 1229 const SourceManager &SM = SourceMgr; 1230 if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) || 1231 !PP.getLangOpts().IsHeaderFile) 1232 Diag(DiagD->getLocation(), diag::warn_unused_const_variable) 1233 << DiagD->getDeclName(); 1234 } else { 1235 if (DiagD->getDescribedVarTemplate()) 1236 Diag(DiagD->getLocation(), diag::warn_unused_template) 1237 << /*variable*/1 << DiagD->getDeclName(); 1238 else 1239 Diag(DiagD->getLocation(), diag::warn_unused_variable) 1240 << DiagD->getDeclName(); 1241 } 1242 } 1243 } 1244 1245 emitAndClearUnusedLocalTypedefWarnings(); 1246 } 1247 1248 if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) { 1249 // FIXME: Load additional unused private field candidates from the external 1250 // source. 1251 RecordCompleteMap RecordsComplete; 1252 RecordCompleteMap MNCComplete; 1253 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(), 1254 E = UnusedPrivateFields.end(); I != E; ++I) { 1255 const NamedDecl *D = *I; 1256 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()); 1257 if (RD && !RD->isUnion() && 1258 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) { 1259 Diag(D->getLocation(), diag::warn_unused_private_field) 1260 << D->getDeclName(); 1261 } 1262 } 1263 } 1264 1265 if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) { 1266 if (ExternalSource) 1267 ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs); 1268 for (const auto &DeletedFieldInfo : DeleteExprs) { 1269 for (const auto &DeleteExprLoc : DeletedFieldInfo.second) { 1270 AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first, 1271 DeleteExprLoc.second); 1272 } 1273 } 1274 } 1275 1276 // Check we've noticed that we're no longer parsing the initializer for every 1277 // variable. If we miss cases, then at best we have a performance issue and 1278 // at worst a rejects-valid bug. 1279 assert(ParsingInitForAutoVars.empty() && 1280 "Didn't unmark var as having its initializer parsed"); 1281 1282 if (!PP.isIncrementalProcessingEnabled()) 1283 TUScope = nullptr; 1284 } 1285 1286 1287 //===----------------------------------------------------------------------===// 1288 // Helper functions. 1289 //===----------------------------------------------------------------------===// 1290 1291 DeclContext *Sema::getFunctionLevelDeclContext() { 1292 DeclContext *DC = CurContext; 1293 1294 while (true) { 1295 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC) || 1296 isa<RequiresExprBodyDecl>(DC)) { 1297 DC = DC->getParent(); 1298 } else if (isa<CXXMethodDecl>(DC) && 1299 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call && 1300 cast<CXXRecordDecl>(DC->getParent())->isLambda()) { 1301 DC = DC->getParent()->getParent(); 1302 } 1303 else break; 1304 } 1305 1306 return DC; 1307 } 1308 1309 /// getCurFunctionDecl - If inside of a function body, this returns a pointer 1310 /// to the function decl for the function being parsed. If we're currently 1311 /// in a 'block', this returns the containing context. 1312 FunctionDecl *Sema::getCurFunctionDecl() { 1313 DeclContext *DC = getFunctionLevelDeclContext(); 1314 return dyn_cast<FunctionDecl>(DC); 1315 } 1316 1317 ObjCMethodDecl *Sema::getCurMethodDecl() { 1318 DeclContext *DC = getFunctionLevelDeclContext(); 1319 while (isa<RecordDecl>(DC)) 1320 DC = DC->getParent(); 1321 return dyn_cast<ObjCMethodDecl>(DC); 1322 } 1323 1324 NamedDecl *Sema::getCurFunctionOrMethodDecl() { 1325 DeclContext *DC = getFunctionLevelDeclContext(); 1326 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC)) 1327 return cast<NamedDecl>(DC); 1328 return nullptr; 1329 } 1330 1331 LangAS Sema::getDefaultCXXMethodAddrSpace() const { 1332 if (getLangOpts().OpenCL) 1333 return LangAS::opencl_generic; 1334 return LangAS::Default; 1335 } 1336 1337 void Sema::EmitCurrentDiagnostic(unsigned DiagID) { 1338 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here 1339 // and yet we also use the current diag ID on the DiagnosticsEngine. This has 1340 // been made more painfully obvious by the refactor that introduced this 1341 // function, but it is possible that the incoming argument can be 1342 // eliminated. If it truly cannot be (for example, there is some reentrancy 1343 // issue I am not seeing yet), then there should at least be a clarifying 1344 // comment somewhere. 1345 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) { 1346 switch (DiagnosticIDs::getDiagnosticSFINAEResponse( 1347 Diags.getCurrentDiagID())) { 1348 case DiagnosticIDs::SFINAE_Report: 1349 // We'll report the diagnostic below. 1350 break; 1351 1352 case DiagnosticIDs::SFINAE_SubstitutionFailure: 1353 // Count this failure so that we know that template argument deduction 1354 // has failed. 1355 ++NumSFINAEErrors; 1356 1357 // Make a copy of this suppressed diagnostic and store it with the 1358 // template-deduction information. 1359 if (*Info && !(*Info)->hasSFINAEDiagnostic()) { 1360 Diagnostic DiagInfo(&Diags); 1361 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), 1362 PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); 1363 } 1364 1365 Diags.setLastDiagnosticIgnored(true); 1366 Diags.Clear(); 1367 return; 1368 1369 case DiagnosticIDs::SFINAE_AccessControl: { 1370 // Per C++ Core Issue 1170, access control is part of SFINAE. 1371 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily 1372 // make access control a part of SFINAE for the purposes of checking 1373 // type traits. 1374 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11) 1375 break; 1376 1377 SourceLocation Loc = Diags.getCurrentDiagLoc(); 1378 1379 // Suppress this diagnostic. 1380 ++NumSFINAEErrors; 1381 1382 // Make a copy of this suppressed diagnostic and store it with the 1383 // template-deduction information. 1384 if (*Info && !(*Info)->hasSFINAEDiagnostic()) { 1385 Diagnostic DiagInfo(&Diags); 1386 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(), 1387 PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); 1388 } 1389 1390 Diags.setLastDiagnosticIgnored(true); 1391 Diags.Clear(); 1392 1393 // Now the diagnostic state is clear, produce a C++98 compatibility 1394 // warning. 1395 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control); 1396 1397 // The last diagnostic which Sema produced was ignored. Suppress any 1398 // notes attached to it. 1399 Diags.setLastDiagnosticIgnored(true); 1400 return; 1401 } 1402 1403 case DiagnosticIDs::SFINAE_Suppress: 1404 // Make a copy of this suppressed diagnostic and store it with the 1405 // template-deduction information; 1406 if (*Info) { 1407 Diagnostic DiagInfo(&Diags); 1408 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(), 1409 PartialDiagnostic(DiagInfo, Context.getDiagAllocator())); 1410 } 1411 1412 // Suppress this diagnostic. 1413 Diags.setLastDiagnosticIgnored(true); 1414 Diags.Clear(); 1415 return; 1416 } 1417 } 1418 1419 // Copy the diagnostic printing policy over the ASTContext printing policy. 1420 // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292 1421 Context.setPrintingPolicy(getPrintingPolicy()); 1422 1423 // Emit the diagnostic. 1424 if (!Diags.EmitCurrentDiagnostic()) 1425 return; 1426 1427 // If this is not a note, and we're in a template instantiation 1428 // that is different from the last template instantiation where 1429 // we emitted an error, print a template instantiation 1430 // backtrace. 1431 if (!DiagnosticIDs::isBuiltinNote(DiagID)) 1432 PrintContextStack(); 1433 } 1434 1435 Sema::SemaDiagnosticBuilder 1436 Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) { 1437 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID())); 1438 PD.Emit(Builder); 1439 1440 return Builder; 1441 } 1442 1443 // Print notes showing how we can reach FD starting from an a priori 1444 // known-callable function. 1445 static void emitCallStackNotes(Sema &S, FunctionDecl *FD) { 1446 auto FnIt = S.DeviceKnownEmittedFns.find(FD); 1447 while (FnIt != S.DeviceKnownEmittedFns.end()) { 1448 // Respect error limit. 1449 if (S.Diags.hasFatalErrorOccurred()) 1450 return; 1451 DiagnosticBuilder Builder( 1452 S.Diags.Report(FnIt->second.Loc, diag::note_called_by)); 1453 Builder << FnIt->second.FD; 1454 FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD); 1455 } 1456 } 1457 1458 namespace { 1459 1460 /// Helper class that emits deferred diagnostic messages if an entity directly 1461 /// or indirectly using the function that causes the deferred diagnostic 1462 /// messages is known to be emitted. 1463 /// 1464 /// During parsing of AST, certain diagnostic messages are recorded as deferred 1465 /// diagnostics since it is unknown whether the functions containing such 1466 /// diagnostics will be emitted. A list of potentially emitted functions and 1467 /// variables that may potentially trigger emission of functions are also 1468 /// recorded. DeferredDiagnosticsEmitter recursively visits used functions 1469 /// by each function to emit deferred diagnostics. 1470 /// 1471 /// During the visit, certain OpenMP directives or initializer of variables 1472 /// with certain OpenMP attributes will cause subsequent visiting of any 1473 /// functions enter a state which is called OpenMP device context in this 1474 /// implementation. The state is exited when the directive or initializer is 1475 /// exited. This state can change the emission states of subsequent uses 1476 /// of functions. 1477 /// 1478 /// Conceptually the functions or variables to be visited form a use graph 1479 /// where the parent node uses the child node. At any point of the visit, 1480 /// the tree nodes traversed from the tree root to the current node form a use 1481 /// stack. The emission state of the current node depends on two factors: 1482 /// 1. the emission state of the root node 1483 /// 2. whether the current node is in OpenMP device context 1484 /// If the function is decided to be emitted, its contained deferred diagnostics 1485 /// are emitted, together with the information about the use stack. 1486 /// 1487 class DeferredDiagnosticsEmitter 1488 : public UsedDeclVisitor<DeferredDiagnosticsEmitter> { 1489 public: 1490 typedef UsedDeclVisitor<DeferredDiagnosticsEmitter> Inherited; 1491 1492 // Whether the function is already in the current use-path. 1493 llvm::SmallSet<CanonicalDeclPtr<Decl>, 4> InUsePath; 1494 1495 // The current use-path. 1496 llvm::SmallVector<CanonicalDeclPtr<FunctionDecl>, 4> UsePath; 1497 1498 // Whether the visiting of the function has been done. Done[0] is for the 1499 // case not in OpenMP device context. Done[1] is for the case in OpenMP 1500 // device context. We need two sets because diagnostics emission may be 1501 // different depending on whether it is in OpenMP device context. 1502 llvm::SmallSet<CanonicalDeclPtr<Decl>, 4> DoneMap[2]; 1503 1504 // Emission state of the root node of the current use graph. 1505 bool ShouldEmitRootNode; 1506 1507 // Current OpenMP device context level. It is initialized to 0 and each 1508 // entering of device context increases it by 1 and each exit decreases 1509 // it by 1. Non-zero value indicates it is currently in device context. 1510 unsigned InOMPDeviceContext; 1511 1512 DeferredDiagnosticsEmitter(Sema &S) 1513 : Inherited(S), ShouldEmitRootNode(false), InOMPDeviceContext(0) {} 1514 1515 void VisitOMPTargetDirective(OMPTargetDirective *Node) { 1516 ++InOMPDeviceContext; 1517 Inherited::VisitOMPTargetDirective(Node); 1518 --InOMPDeviceContext; 1519 } 1520 1521 void visitUsedDecl(SourceLocation Loc, Decl *D) { 1522 if (isa<VarDecl>(D)) 1523 return; 1524 if (auto *FD = dyn_cast<FunctionDecl>(D)) 1525 checkFunc(Loc, FD); 1526 else 1527 Inherited::visitUsedDecl(Loc, D); 1528 } 1529 1530 void checkVar(VarDecl *VD) { 1531 assert(VD->isFileVarDecl() && 1532 "Should only check file-scope variables"); 1533 if (auto *Init = VD->getInit()) { 1534 auto DevTy = OMPDeclareTargetDeclAttr::getDeviceType(VD); 1535 bool IsDev = DevTy && (*DevTy == OMPDeclareTargetDeclAttr::DT_NoHost || 1536 *DevTy == OMPDeclareTargetDeclAttr::DT_Any); 1537 if (IsDev) 1538 ++InOMPDeviceContext; 1539 this->Visit(Init); 1540 if (IsDev) 1541 --InOMPDeviceContext; 1542 } 1543 } 1544 1545 void checkFunc(SourceLocation Loc, FunctionDecl *FD) { 1546 auto &Done = DoneMap[InOMPDeviceContext > 0 ? 1 : 0]; 1547 FunctionDecl *Caller = UsePath.empty() ? nullptr : UsePath.back(); 1548 if ((!ShouldEmitRootNode && !S.getLangOpts().OpenMP && !Caller) || 1549 S.shouldIgnoreInHostDeviceCheck(FD) || InUsePath.count(FD)) 1550 return; 1551 // Finalize analysis of OpenMP-specific constructs. 1552 if (Caller && S.LangOpts.OpenMP && UsePath.size() == 1) 1553 S.finalizeOpenMPDelayedAnalysis(Caller, FD, Loc); 1554 if (Caller) 1555 S.DeviceKnownEmittedFns[FD] = {Caller, Loc}; 1556 // Always emit deferred diagnostics for the direct users. This does not 1557 // lead to explosion of diagnostics since each user is visited at most 1558 // twice. 1559 if (ShouldEmitRootNode || InOMPDeviceContext) 1560 emitDeferredDiags(FD, Caller); 1561 // Do not revisit a function if the function body has been completely 1562 // visited before. 1563 if (!Done.insert(FD).second) 1564 return; 1565 InUsePath.insert(FD); 1566 UsePath.push_back(FD); 1567 if (auto *S = FD->getBody()) { 1568 this->Visit(S); 1569 } 1570 UsePath.pop_back(); 1571 InUsePath.erase(FD); 1572 } 1573 1574 void checkRecordedDecl(Decl *D) { 1575 if (auto *FD = dyn_cast<FunctionDecl>(D)) { 1576 ShouldEmitRootNode = S.getEmissionStatus(FD, /*Final=*/true) == 1577 Sema::FunctionEmissionStatus::Emitted; 1578 checkFunc(SourceLocation(), FD); 1579 } else 1580 checkVar(cast<VarDecl>(D)); 1581 } 1582 1583 // Emit any deferred diagnostics for FD 1584 void emitDeferredDiags(FunctionDecl *FD, bool ShowCallStack) { 1585 auto It = S.DeviceDeferredDiags.find(FD); 1586 if (It == S.DeviceDeferredDiags.end()) 1587 return; 1588 bool HasWarningOrError = false; 1589 bool FirstDiag = true; 1590 for (PartialDiagnosticAt &PDAt : It->second) { 1591 // Respect error limit. 1592 if (S.Diags.hasFatalErrorOccurred()) 1593 return; 1594 const SourceLocation &Loc = PDAt.first; 1595 const PartialDiagnostic &PD = PDAt.second; 1596 HasWarningOrError |= 1597 S.getDiagnostics().getDiagnosticLevel(PD.getDiagID(), Loc) >= 1598 DiagnosticsEngine::Warning; 1599 { 1600 DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID())); 1601 PD.Emit(Builder); 1602 } 1603 // Emit the note on the first diagnostic in case too many diagnostics 1604 // cause the note not emitted. 1605 if (FirstDiag && HasWarningOrError && ShowCallStack) { 1606 emitCallStackNotes(S, FD); 1607 FirstDiag = false; 1608 } 1609 } 1610 } 1611 }; 1612 } // namespace 1613 1614 void Sema::emitDeferredDiags() { 1615 if (ExternalSource) 1616 ExternalSource->ReadDeclsToCheckForDeferredDiags( 1617 DeclsToCheckForDeferredDiags); 1618 1619 if ((DeviceDeferredDiags.empty() && !LangOpts.OpenMP) || 1620 DeclsToCheckForDeferredDiags.empty()) 1621 return; 1622 1623 DeferredDiagnosticsEmitter DDE(*this); 1624 for (auto D : DeclsToCheckForDeferredDiags) 1625 DDE.checkRecordedDecl(D); 1626 } 1627 1628 // In CUDA, there are some constructs which may appear in semantically-valid 1629 // code, but trigger errors if we ever generate code for the function in which 1630 // they appear. Essentially every construct you're not allowed to use on the 1631 // device falls into this category, because you are allowed to use these 1632 // constructs in a __host__ __device__ function, but only if that function is 1633 // never codegen'ed on the device. 1634 // 1635 // To handle semantic checking for these constructs, we keep track of the set of 1636 // functions we know will be emitted, either because we could tell a priori that 1637 // they would be emitted, or because they were transitively called by a 1638 // known-emitted function. 1639 // 1640 // We also keep a partial call graph of which not-known-emitted functions call 1641 // which other not-known-emitted functions. 1642 // 1643 // When we see something which is illegal if the current function is emitted 1644 // (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or 1645 // CheckCUDACall), we first check if the current function is known-emitted. If 1646 // so, we immediately output the diagnostic. 1647 // 1648 // Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags 1649 // until we discover that the function is known-emitted, at which point we take 1650 // it out of this map and emit the diagnostic. 1651 1652 Sema::DeviceDiagBuilder::DeviceDiagBuilder(Kind K, SourceLocation Loc, 1653 unsigned DiagID, FunctionDecl *Fn, 1654 Sema &S) 1655 : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn), 1656 ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) { 1657 switch (K) { 1658 case K_Nop: 1659 break; 1660 case K_Immediate: 1661 case K_ImmediateWithCallStack: 1662 ImmediateDiag.emplace(S.Diag(Loc, DiagID)); 1663 break; 1664 case K_Deferred: 1665 assert(Fn && "Must have a function to attach the deferred diag to."); 1666 auto &Diags = S.DeviceDeferredDiags[Fn]; 1667 PartialDiagId.emplace(Diags.size()); 1668 Diags.emplace_back(Loc, S.PDiag(DiagID)); 1669 break; 1670 } 1671 } 1672 1673 Sema::DeviceDiagBuilder::DeviceDiagBuilder(DeviceDiagBuilder &&D) 1674 : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn), 1675 ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag), 1676 PartialDiagId(D.PartialDiagId) { 1677 // Clean the previous diagnostics. 1678 D.ShowCallStack = false; 1679 D.ImmediateDiag.reset(); 1680 D.PartialDiagId.reset(); 1681 } 1682 1683 Sema::DeviceDiagBuilder::~DeviceDiagBuilder() { 1684 if (ImmediateDiag) { 1685 // Emit our diagnostic and, if it was a warning or error, output a callstack 1686 // if Fn isn't a priori known-emitted. 1687 bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel( 1688 DiagID, Loc) >= DiagnosticsEngine::Warning; 1689 ImmediateDiag.reset(); // Emit the immediate diag. 1690 if (IsWarningOrError && ShowCallStack) 1691 emitCallStackNotes(S, Fn); 1692 } else { 1693 assert((!PartialDiagId || ShowCallStack) && 1694 "Must always show call stack for deferred diags."); 1695 } 1696 } 1697 1698 Sema::DeviceDiagBuilder Sema::targetDiag(SourceLocation Loc, unsigned DiagID) { 1699 if (LangOpts.OpenMP) 1700 return LangOpts.OpenMPIsDevice ? diagIfOpenMPDeviceCode(Loc, DiagID) 1701 : diagIfOpenMPHostCode(Loc, DiagID); 1702 if (getLangOpts().CUDA) 1703 return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID) 1704 : CUDADiagIfHostCode(Loc, DiagID); 1705 1706 if (getLangOpts().SYCLIsDevice) 1707 return SYCLDiagIfDeviceCode(Loc, DiagID); 1708 1709 return DeviceDiagBuilder(DeviceDiagBuilder::K_Immediate, Loc, DiagID, 1710 getCurFunctionDecl(), *this); 1711 } 1712 1713 void Sema::checkDeviceDecl(const ValueDecl *D, SourceLocation Loc) { 1714 if (isUnevaluatedContext()) 1715 return; 1716 1717 Decl *C = cast<Decl>(getCurLexicalContext()); 1718 1719 // Memcpy operations for structs containing a member with unsupported type 1720 // are ok, though. 1721 if (const auto *MD = dyn_cast<CXXMethodDecl>(C)) { 1722 if ((MD->isCopyAssignmentOperator() || MD->isMoveAssignmentOperator()) && 1723 MD->isTrivial()) 1724 return; 1725 1726 if (const auto *Ctor = dyn_cast<CXXConstructorDecl>(MD)) 1727 if (Ctor->isCopyOrMoveConstructor() && Ctor->isTrivial()) 1728 return; 1729 } 1730 1731 auto CheckType = [&](QualType Ty) { 1732 if (Ty->isDependentType()) 1733 return; 1734 1735 if ((Ty->isFloat16Type() && !Context.getTargetInfo().hasFloat16Type()) || 1736 ((Ty->isFloat128Type() || 1737 (Ty->isRealFloatingType() && Context.getTypeSize(Ty) == 128)) && 1738 !Context.getTargetInfo().hasFloat128Type()) || 1739 (Ty->isIntegerType() && Context.getTypeSize(Ty) == 128 && 1740 !Context.getTargetInfo().hasInt128Type())) { 1741 targetDiag(Loc, diag::err_device_unsupported_type) 1742 << D << static_cast<unsigned>(Context.getTypeSize(Ty)) << Ty 1743 << Context.getTargetInfo().getTriple().str(); 1744 targetDiag(D->getLocation(), diag::note_defined_here) << D; 1745 } 1746 }; 1747 1748 QualType Ty = D->getType(); 1749 CheckType(Ty); 1750 1751 if (const auto *FPTy = dyn_cast<FunctionProtoType>(Ty)) { 1752 for (const auto &ParamTy : FPTy->param_types()) 1753 CheckType(ParamTy); 1754 CheckType(FPTy->getReturnType()); 1755 } 1756 } 1757 1758 /// Looks through the macro-expansion chain for the given 1759 /// location, looking for a macro expansion with the given name. 1760 /// If one is found, returns true and sets the location to that 1761 /// expansion loc. 1762 bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) { 1763 SourceLocation loc = locref; 1764 if (!loc.isMacroID()) return false; 1765 1766 // There's no good way right now to look at the intermediate 1767 // expansions, so just jump to the expansion location. 1768 loc = getSourceManager().getExpansionLoc(loc); 1769 1770 // If that's written with the name, stop here. 1771 SmallVector<char, 16> buffer; 1772 if (getPreprocessor().getSpelling(loc, buffer) == name) { 1773 locref = loc; 1774 return true; 1775 } 1776 return false; 1777 } 1778 1779 /// Determines the active Scope associated with the given declaration 1780 /// context. 1781 /// 1782 /// This routine maps a declaration context to the active Scope object that 1783 /// represents that declaration context in the parser. It is typically used 1784 /// from "scope-less" code (e.g., template instantiation, lazy creation of 1785 /// declarations) that injects a name for name-lookup purposes and, therefore, 1786 /// must update the Scope. 1787 /// 1788 /// \returns The scope corresponding to the given declaraion context, or NULL 1789 /// if no such scope is open. 1790 Scope *Sema::getScopeForContext(DeclContext *Ctx) { 1791 1792 if (!Ctx) 1793 return nullptr; 1794 1795 Ctx = Ctx->getPrimaryContext(); 1796 for (Scope *S = getCurScope(); S; S = S->getParent()) { 1797 // Ignore scopes that cannot have declarations. This is important for 1798 // out-of-line definitions of static class members. 1799 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope)) 1800 if (DeclContext *Entity = S->getEntity()) 1801 if (Ctx == Entity->getPrimaryContext()) 1802 return S; 1803 } 1804 1805 return nullptr; 1806 } 1807 1808 /// Enter a new function scope 1809 void Sema::PushFunctionScope() { 1810 if (FunctionScopes.empty() && CachedFunctionScope) { 1811 // Use CachedFunctionScope to avoid allocating memory when possible. 1812 CachedFunctionScope->Clear(); 1813 FunctionScopes.push_back(CachedFunctionScope.release()); 1814 } else { 1815 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics())); 1816 } 1817 if (LangOpts.OpenMP) 1818 pushOpenMPFunctionRegion(); 1819 } 1820 1821 void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) { 1822 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(), 1823 BlockScope, Block)); 1824 } 1825 1826 LambdaScopeInfo *Sema::PushLambdaScope() { 1827 LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics()); 1828 FunctionScopes.push_back(LSI); 1829 return LSI; 1830 } 1831 1832 void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) { 1833 if (LambdaScopeInfo *const LSI = getCurLambda()) { 1834 LSI->AutoTemplateParameterDepth = Depth; 1835 return; 1836 } 1837 llvm_unreachable( 1838 "Remove assertion if intentionally called in a non-lambda context."); 1839 } 1840 1841 // Check that the type of the VarDecl has an accessible copy constructor and 1842 // resolve its destructor's exception specification. 1843 static void checkEscapingByref(VarDecl *VD, Sema &S) { 1844 QualType T = VD->getType(); 1845 EnterExpressionEvaluationContext scope( 1846 S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated); 1847 SourceLocation Loc = VD->getLocation(); 1848 Expr *VarRef = 1849 new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc); 1850 ExprResult Result = S.PerformMoveOrCopyInitialization( 1851 InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(), 1852 VarRef, /*AllowNRVO=*/true); 1853 if (!Result.isInvalid()) { 1854 Result = S.MaybeCreateExprWithCleanups(Result); 1855 Expr *Init = Result.getAs<Expr>(); 1856 S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init)); 1857 } 1858 1859 // The destructor's exception specification is needed when IRGen generates 1860 // block copy/destroy functions. Resolve it here. 1861 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl()) 1862 if (CXXDestructorDecl *DD = RD->getDestructor()) { 1863 auto *FPT = DD->getType()->getAs<FunctionProtoType>(); 1864 S.ResolveExceptionSpec(Loc, FPT); 1865 } 1866 } 1867 1868 static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) { 1869 // Set the EscapingByref flag of __block variables captured by 1870 // escaping blocks. 1871 for (const BlockDecl *BD : FSI.Blocks) { 1872 for (const BlockDecl::Capture &BC : BD->captures()) { 1873 VarDecl *VD = BC.getVariable(); 1874 if (VD->hasAttr<BlocksAttr>()) { 1875 // Nothing to do if this is a __block variable captured by a 1876 // non-escaping block. 1877 if (BD->doesNotEscape()) 1878 continue; 1879 VD->setEscapingByref(); 1880 } 1881 // Check whether the captured variable is or contains an object of 1882 // non-trivial C union type. 1883 QualType CapType = BC.getVariable()->getType(); 1884 if (CapType.hasNonTrivialToPrimitiveDestructCUnion() || 1885 CapType.hasNonTrivialToPrimitiveCopyCUnion()) 1886 S.checkNonTrivialCUnion(BC.getVariable()->getType(), 1887 BD->getCaretLocation(), 1888 Sema::NTCUC_BlockCapture, 1889 Sema::NTCUK_Destruct|Sema::NTCUK_Copy); 1890 } 1891 } 1892 1893 for (VarDecl *VD : FSI.ByrefBlockVars) { 1894 // __block variables might require us to capture a copy-initializer. 1895 if (!VD->isEscapingByref()) 1896 continue; 1897 // It's currently invalid to ever have a __block variable with an 1898 // array type; should we diagnose that here? 1899 // Regardless, we don't want to ignore array nesting when 1900 // constructing this copy. 1901 if (VD->getType()->isStructureOrClassType()) 1902 checkEscapingByref(VD, S); 1903 } 1904 } 1905 1906 /// Pop a function (or block or lambda or captured region) scope from the stack. 1907 /// 1908 /// \param WP The warning policy to use for CFG-based warnings, or null if such 1909 /// warnings should not be produced. 1910 /// \param D The declaration corresponding to this function scope, if producing 1911 /// CFG-based warnings. 1912 /// \param BlockType The type of the block expression, if D is a BlockDecl. 1913 Sema::PoppedFunctionScopePtr 1914 Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP, 1915 const Decl *D, QualType BlockType) { 1916 assert(!FunctionScopes.empty() && "mismatched push/pop!"); 1917 1918 markEscapingByrefs(*FunctionScopes.back(), *this); 1919 1920 PoppedFunctionScopePtr Scope(FunctionScopes.pop_back_val(), 1921 PoppedFunctionScopeDeleter(this)); 1922 1923 if (LangOpts.OpenMP) 1924 popOpenMPFunctionRegion(Scope.get()); 1925 1926 // Issue any analysis-based warnings. 1927 if (WP && D) 1928 AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType); 1929 else 1930 for (const auto &PUD : Scope->PossiblyUnreachableDiags) 1931 Diag(PUD.Loc, PUD.PD); 1932 1933 return Scope; 1934 } 1935 1936 void Sema::PoppedFunctionScopeDeleter:: 1937 operator()(sema::FunctionScopeInfo *Scope) const { 1938 // Stash the function scope for later reuse if it's for a normal function. 1939 if (Scope->isPlainFunction() && !Self->CachedFunctionScope) 1940 Self->CachedFunctionScope.reset(Scope); 1941 else 1942 delete Scope; 1943 } 1944 1945 void Sema::PushCompoundScope(bool IsStmtExpr) { 1946 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr)); 1947 } 1948 1949 void Sema::PopCompoundScope() { 1950 FunctionScopeInfo *CurFunction = getCurFunction(); 1951 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop"); 1952 1953 CurFunction->CompoundScopes.pop_back(); 1954 } 1955 1956 /// Determine whether any errors occurred within this function/method/ 1957 /// block. 1958 bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const { 1959 return getCurFunction()->hasUnrecoverableErrorOccurred(); 1960 } 1961 1962 void Sema::setFunctionHasBranchIntoScope() { 1963 if (!FunctionScopes.empty()) 1964 FunctionScopes.back()->setHasBranchIntoScope(); 1965 } 1966 1967 void Sema::setFunctionHasBranchProtectedScope() { 1968 if (!FunctionScopes.empty()) 1969 FunctionScopes.back()->setHasBranchProtectedScope(); 1970 } 1971 1972 void Sema::setFunctionHasIndirectGoto() { 1973 if (!FunctionScopes.empty()) 1974 FunctionScopes.back()->setHasIndirectGoto(); 1975 } 1976 1977 BlockScopeInfo *Sema::getCurBlock() { 1978 if (FunctionScopes.empty()) 1979 return nullptr; 1980 1981 auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back()); 1982 if (CurBSI && CurBSI->TheDecl && 1983 !CurBSI->TheDecl->Encloses(CurContext)) { 1984 // We have switched contexts due to template instantiation. 1985 assert(!CodeSynthesisContexts.empty()); 1986 return nullptr; 1987 } 1988 1989 return CurBSI; 1990 } 1991 1992 FunctionScopeInfo *Sema::getEnclosingFunction() const { 1993 if (FunctionScopes.empty()) 1994 return nullptr; 1995 1996 for (int e = FunctionScopes.size() - 1; e >= 0; --e) { 1997 if (isa<sema::BlockScopeInfo>(FunctionScopes[e])) 1998 continue; 1999 return FunctionScopes[e]; 2000 } 2001 return nullptr; 2002 } 2003 2004 LambdaScopeInfo *Sema::getEnclosingLambda() const { 2005 for (auto *Scope : llvm::reverse(FunctionScopes)) { 2006 if (auto *LSI = dyn_cast<sema::LambdaScopeInfo>(Scope)) { 2007 if (LSI->Lambda && !LSI->Lambda->Encloses(CurContext)) { 2008 // We have switched contexts due to template instantiation. 2009 // FIXME: We should swap out the FunctionScopes during code synthesis 2010 // so that we don't need to check for this. 2011 assert(!CodeSynthesisContexts.empty()); 2012 return nullptr; 2013 } 2014 return LSI; 2015 } 2016 } 2017 return nullptr; 2018 } 2019 2020 LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) { 2021 if (FunctionScopes.empty()) 2022 return nullptr; 2023 2024 auto I = FunctionScopes.rbegin(); 2025 if (IgnoreNonLambdaCapturingScope) { 2026 auto E = FunctionScopes.rend(); 2027 while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I)) 2028 ++I; 2029 if (I == E) 2030 return nullptr; 2031 } 2032 auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I); 2033 if (CurLSI && CurLSI->Lambda && 2034 !CurLSI->Lambda->Encloses(CurContext)) { 2035 // We have switched contexts due to template instantiation. 2036 assert(!CodeSynthesisContexts.empty()); 2037 return nullptr; 2038 } 2039 2040 return CurLSI; 2041 } 2042 2043 // We have a generic lambda if we parsed auto parameters, or we have 2044 // an associated template parameter list. 2045 LambdaScopeInfo *Sema::getCurGenericLambda() { 2046 if (LambdaScopeInfo *LSI = getCurLambda()) { 2047 return (LSI->TemplateParams.size() || 2048 LSI->GLTemplateParameterList) ? LSI : nullptr; 2049 } 2050 return nullptr; 2051 } 2052 2053 2054 void Sema::ActOnComment(SourceRange Comment) { 2055 if (!LangOpts.RetainCommentsFromSystemHeaders && 2056 SourceMgr.isInSystemHeader(Comment.getBegin())) 2057 return; 2058 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false); 2059 if (RC.isAlmostTrailingComment()) { 2060 SourceRange MagicMarkerRange(Comment.getBegin(), 2061 Comment.getBegin().getLocWithOffset(3)); 2062 StringRef MagicMarkerText; 2063 switch (RC.getKind()) { 2064 case RawComment::RCK_OrdinaryBCPL: 2065 MagicMarkerText = "///<"; 2066 break; 2067 case RawComment::RCK_OrdinaryC: 2068 MagicMarkerText = "/**<"; 2069 break; 2070 default: 2071 llvm_unreachable("if this is an almost Doxygen comment, " 2072 "it should be ordinary"); 2073 } 2074 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) << 2075 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText); 2076 } 2077 Context.addComment(RC); 2078 } 2079 2080 // Pin this vtable to this file. 2081 ExternalSemaSource::~ExternalSemaSource() {} 2082 char ExternalSemaSource::ID; 2083 2084 void ExternalSemaSource::ReadMethodPool(Selector Sel) { } 2085 void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { } 2086 2087 void ExternalSemaSource::ReadKnownNamespaces( 2088 SmallVectorImpl<NamespaceDecl *> &Namespaces) { 2089 } 2090 2091 void ExternalSemaSource::ReadUndefinedButUsed( 2092 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {} 2093 2094 void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector< 2095 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {} 2096 2097 /// Figure out if an expression could be turned into a call. 2098 /// 2099 /// Use this when trying to recover from an error where the programmer may have 2100 /// written just the name of a function instead of actually calling it. 2101 /// 2102 /// \param E - The expression to examine. 2103 /// \param ZeroArgCallReturnTy - If the expression can be turned into a call 2104 /// with no arguments, this parameter is set to the type returned by such a 2105 /// call; otherwise, it is set to an empty QualType. 2106 /// \param OverloadSet - If the expression is an overloaded function 2107 /// name, this parameter is populated with the decls of the various overloads. 2108 bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy, 2109 UnresolvedSetImpl &OverloadSet) { 2110 ZeroArgCallReturnTy = QualType(); 2111 OverloadSet.clear(); 2112 2113 const OverloadExpr *Overloads = nullptr; 2114 bool IsMemExpr = false; 2115 if (E.getType() == Context.OverloadTy) { 2116 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E)); 2117 2118 // Ignore overloads that are pointer-to-member constants. 2119 if (FR.HasFormOfMemberPointer) 2120 return false; 2121 2122 Overloads = FR.Expression; 2123 } else if (E.getType() == Context.BoundMemberTy) { 2124 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens()); 2125 IsMemExpr = true; 2126 } 2127 2128 bool Ambiguous = false; 2129 bool IsMV = false; 2130 2131 if (Overloads) { 2132 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(), 2133 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) { 2134 OverloadSet.addDecl(*it); 2135 2136 // Check whether the function is a non-template, non-member which takes no 2137 // arguments. 2138 if (IsMemExpr) 2139 continue; 2140 if (const FunctionDecl *OverloadDecl 2141 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) { 2142 if (OverloadDecl->getMinRequiredArguments() == 0) { 2143 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous && 2144 (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() || 2145 OverloadDecl->isCPUSpecificMultiVersion()))) { 2146 ZeroArgCallReturnTy = QualType(); 2147 Ambiguous = true; 2148 } else { 2149 ZeroArgCallReturnTy = OverloadDecl->getReturnType(); 2150 IsMV = OverloadDecl->isCPUDispatchMultiVersion() || 2151 OverloadDecl->isCPUSpecificMultiVersion(); 2152 } 2153 } 2154 } 2155 } 2156 2157 // If it's not a member, use better machinery to try to resolve the call 2158 if (!IsMemExpr) 2159 return !ZeroArgCallReturnTy.isNull(); 2160 } 2161 2162 // Attempt to call the member with no arguments - this will correctly handle 2163 // member templates with defaults/deduction of template arguments, overloads 2164 // with default arguments, etc. 2165 if (IsMemExpr && !E.isTypeDependent()) { 2166 Sema::TentativeAnalysisScope Trap(*this); 2167 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(), 2168 None, SourceLocation()); 2169 if (R.isUsable()) { 2170 ZeroArgCallReturnTy = R.get()->getType(); 2171 return true; 2172 } 2173 return false; 2174 } 2175 2176 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) { 2177 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) { 2178 if (Fun->getMinRequiredArguments() == 0) 2179 ZeroArgCallReturnTy = Fun->getReturnType(); 2180 return true; 2181 } 2182 } 2183 2184 // We don't have an expression that's convenient to get a FunctionDecl from, 2185 // but we can at least check if the type is "function of 0 arguments". 2186 QualType ExprTy = E.getType(); 2187 const FunctionType *FunTy = nullptr; 2188 QualType PointeeTy = ExprTy->getPointeeType(); 2189 if (!PointeeTy.isNull()) 2190 FunTy = PointeeTy->getAs<FunctionType>(); 2191 if (!FunTy) 2192 FunTy = ExprTy->getAs<FunctionType>(); 2193 2194 if (const FunctionProtoType *FPT = 2195 dyn_cast_or_null<FunctionProtoType>(FunTy)) { 2196 if (FPT->getNumParams() == 0) 2197 ZeroArgCallReturnTy = FunTy->getReturnType(); 2198 return true; 2199 } 2200 return false; 2201 } 2202 2203 /// Give notes for a set of overloads. 2204 /// 2205 /// A companion to tryExprAsCall. In cases when the name that the programmer 2206 /// wrote was an overloaded function, we may be able to make some guesses about 2207 /// plausible overloads based on their return types; such guesses can be handed 2208 /// off to this method to be emitted as notes. 2209 /// 2210 /// \param Overloads - The overloads to note. 2211 /// \param FinalNoteLoc - If we've suppressed printing some overloads due to 2212 /// -fshow-overloads=best, this is the location to attach to the note about too 2213 /// many candidates. Typically this will be the location of the original 2214 /// ill-formed expression. 2215 static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads, 2216 const SourceLocation FinalNoteLoc) { 2217 int ShownOverloads = 0; 2218 int SuppressedOverloads = 0; 2219 for (UnresolvedSetImpl::iterator It = Overloads.begin(), 2220 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { 2221 // FIXME: Magic number for max shown overloads stolen from 2222 // OverloadCandidateSet::NoteCandidates. 2223 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) { 2224 ++SuppressedOverloads; 2225 continue; 2226 } 2227 2228 NamedDecl *Fn = (*It)->getUnderlyingDecl(); 2229 // Don't print overloads for non-default multiversioned functions. 2230 if (const auto *FD = Fn->getAsFunction()) { 2231 if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() && 2232 !FD->getAttr<TargetAttr>()->isDefaultVersion()) 2233 continue; 2234 } 2235 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call); 2236 ++ShownOverloads; 2237 } 2238 2239 if (SuppressedOverloads) 2240 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates) 2241 << SuppressedOverloads; 2242 } 2243 2244 static void notePlausibleOverloads(Sema &S, SourceLocation Loc, 2245 const UnresolvedSetImpl &Overloads, 2246 bool (*IsPlausibleResult)(QualType)) { 2247 if (!IsPlausibleResult) 2248 return noteOverloads(S, Overloads, Loc); 2249 2250 UnresolvedSet<2> PlausibleOverloads; 2251 for (OverloadExpr::decls_iterator It = Overloads.begin(), 2252 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) { 2253 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It); 2254 QualType OverloadResultTy = OverloadDecl->getReturnType(); 2255 if (IsPlausibleResult(OverloadResultTy)) 2256 PlausibleOverloads.addDecl(It.getDecl()); 2257 } 2258 noteOverloads(S, PlausibleOverloads, Loc); 2259 } 2260 2261 /// Determine whether the given expression can be called by just 2262 /// putting parentheses after it. Notably, expressions with unary 2263 /// operators can't be because the unary operator will start parsing 2264 /// outside the call. 2265 static bool IsCallableWithAppend(Expr *E) { 2266 E = E->IgnoreImplicit(); 2267 return (!isa<CStyleCastExpr>(E) && 2268 !isa<UnaryOperator>(E) && 2269 !isa<BinaryOperator>(E) && 2270 !isa<CXXOperatorCallExpr>(E)); 2271 } 2272 2273 static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) { 2274 if (const auto *UO = dyn_cast<UnaryOperator>(E)) 2275 E = UO->getSubExpr(); 2276 2277 if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) { 2278 if (ULE->getNumDecls() == 0) 2279 return false; 2280 2281 const NamedDecl *ND = *ULE->decls_begin(); 2282 if (const auto *FD = dyn_cast<FunctionDecl>(ND)) 2283 return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion(); 2284 } 2285 return false; 2286 } 2287 2288 bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD, 2289 bool ForceComplain, 2290 bool (*IsPlausibleResult)(QualType)) { 2291 SourceLocation Loc = E.get()->getExprLoc(); 2292 SourceRange Range = E.get()->getSourceRange(); 2293 2294 QualType ZeroArgCallTy; 2295 UnresolvedSet<4> Overloads; 2296 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) && 2297 !ZeroArgCallTy.isNull() && 2298 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) { 2299 // At this point, we know E is potentially callable with 0 2300 // arguments and that it returns something of a reasonable type, 2301 // so we can emit a fixit and carry on pretending that E was 2302 // actually a CallExpr. 2303 SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd()); 2304 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get()); 2305 Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range 2306 << (IsCallableWithAppend(E.get()) 2307 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()") 2308 : FixItHint()); 2309 if (!IsMV) 2310 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); 2311 2312 // FIXME: Try this before emitting the fixit, and suppress diagnostics 2313 // while doing so. 2314 E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None, 2315 Range.getEnd().getLocWithOffset(1)); 2316 return true; 2317 } 2318 2319 if (!ForceComplain) return false; 2320 2321 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get()); 2322 Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range; 2323 if (!IsMV) 2324 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult); 2325 E = ExprError(); 2326 return true; 2327 } 2328 2329 IdentifierInfo *Sema::getSuperIdentifier() const { 2330 if (!Ident_super) 2331 Ident_super = &Context.Idents.get("super"); 2332 return Ident_super; 2333 } 2334 2335 IdentifierInfo *Sema::getFloat128Identifier() const { 2336 if (!Ident___float128) 2337 Ident___float128 = &Context.Idents.get("__float128"); 2338 return Ident___float128; 2339 } 2340 2341 void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD, 2342 CapturedRegionKind K, 2343 unsigned OpenMPCaptureLevel) { 2344 auto *CSI = new CapturedRegionScopeInfo( 2345 getDiagnostics(), S, CD, RD, CD->getContextParam(), K, 2346 (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0, 2347 OpenMPCaptureLevel); 2348 CSI->ReturnType = Context.VoidTy; 2349 FunctionScopes.push_back(CSI); 2350 } 2351 2352 CapturedRegionScopeInfo *Sema::getCurCapturedRegion() { 2353 if (FunctionScopes.empty()) 2354 return nullptr; 2355 2356 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back()); 2357 } 2358 2359 const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> & 2360 Sema::getMismatchingDeleteExpressions() const { 2361 return DeleteExprs; 2362 } 2363 2364 void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) { 2365 if (ExtStr.empty()) 2366 return; 2367 llvm::SmallVector<StringRef, 1> Exts; 2368 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false); 2369 auto CanT = T.getCanonicalType().getTypePtr(); 2370 for (auto &I : Exts) 2371 OpenCLTypeExtMap[CanT].insert(I.str()); 2372 } 2373 2374 void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) { 2375 llvm::SmallVector<StringRef, 1> Exts; 2376 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false); 2377 if (Exts.empty()) 2378 return; 2379 for (auto &I : Exts) 2380 OpenCLDeclExtMap[FD].insert(I.str()); 2381 } 2382 2383 void Sema::setCurrentOpenCLExtensionForType(QualType T) { 2384 if (CurrOpenCLExtension.empty()) 2385 return; 2386 setOpenCLExtensionForType(T, CurrOpenCLExtension); 2387 } 2388 2389 void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) { 2390 if (CurrOpenCLExtension.empty()) 2391 return; 2392 setOpenCLExtensionForDecl(D, CurrOpenCLExtension); 2393 } 2394 2395 std::string Sema::getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD) { 2396 if (!OpenCLDeclExtMap.empty()) 2397 return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap); 2398 2399 return ""; 2400 } 2401 2402 std::string Sema::getOpenCLExtensionsFromTypeExtMap(FunctionType *FT) { 2403 if (!OpenCLTypeExtMap.empty()) 2404 return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap); 2405 2406 return ""; 2407 } 2408 2409 template <typename T, typename MapT> 2410 std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) { 2411 auto Loc = Map.find(FDT); 2412 return llvm::join(Loc->second, " "); 2413 } 2414 2415 bool Sema::isOpenCLDisabledDecl(Decl *FD) { 2416 auto Loc = OpenCLDeclExtMap.find(FD); 2417 if (Loc == OpenCLDeclExtMap.end()) 2418 return false; 2419 for (auto &I : Loc->second) { 2420 if (!getOpenCLOptions().isEnabled(I)) 2421 return true; 2422 } 2423 return false; 2424 } 2425 2426 template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT> 2427 bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc, 2428 DiagInfoT DiagInfo, MapT &Map, 2429 unsigned Selector, 2430 SourceRange SrcRange) { 2431 auto Loc = Map.find(D); 2432 if (Loc == Map.end()) 2433 return false; 2434 bool Disabled = false; 2435 for (auto &I : Loc->second) { 2436 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) { 2437 Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo 2438 << I << SrcRange; 2439 Disabled = true; 2440 } 2441 } 2442 return Disabled; 2443 } 2444 2445 bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) { 2446 // Check extensions for declared types. 2447 Decl *Decl = nullptr; 2448 if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr())) 2449 Decl = TypedefT->getDecl(); 2450 if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr())) 2451 Decl = TagT->getDecl(); 2452 auto Loc = DS.getTypeSpecTypeLoc(); 2453 2454 // Check extensions for vector types. 2455 // e.g. double4 is not allowed when cl_khr_fp64 is absent. 2456 if (QT->isExtVectorType()) { 2457 auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr(); 2458 return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap); 2459 } 2460 2461 if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap)) 2462 return true; 2463 2464 // Check extensions for builtin types. 2465 return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc, 2466 QT, OpenCLTypeExtMap); 2467 } 2468 2469 bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) { 2470 IdentifierInfo *FnName = D.getIdentifier(); 2471 return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName, 2472 OpenCLDeclExtMap, 1, D.getSourceRange()); 2473 } 2474