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