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