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