blob: 3941643893af61151fea68299e295eb864d680ea [file] [log] [blame]
Chris Lattnerddd6fc82006-11-10 04:58:55 +00001//===--- Sema.cpp - AST Builder and Semantic Analysis Implementation ------===//
Chris Lattner3e7bd4e2006-08-17 05:51:27 +00002//
Chandler Carruth2946cd72019-01-19 08:50:56 +00003// 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
Chris Lattner3e7bd4e2006-08-17 05:51:27 +00006//
7//===----------------------------------------------------------------------===//
8//
Chris Lattnerddd6fc82006-11-10 04:58:55 +00009// This file implements the actions class which performs semantic analysis and
10// builds an AST out of a parse stream.
Chris Lattner3e7bd4e2006-08-17 05:51:27 +000011//
12//===----------------------------------------------------------------------===//
13
Chris Lattnercb6a3822006-11-10 06:20:45 +000014#include "clang/AST/ASTContext.h"
Douglas Gregor639cccc2010-02-09 22:26:47 +000015#include "clang/AST/ASTDiagnostic.h"
John McCall28a0cf72010-08-25 07:42:41 +000016#include "clang/AST/DeclCXX.h"
Daniel Jasper0baec5492012-06-06 08:32:04 +000017#include "clang/AST/DeclFriend.h"
Daniel Dunbar6e8aa532008-08-11 05:35:13 +000018#include "clang/AST/DeclObjC.h"
Daniel Dunbar221fa942008-08-11 04:54:23 +000019#include "clang/AST/Expr.h"
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +000020#include "clang/AST/ExprCXX.h"
Jordan Rose1e879d82018-03-23 00:07:18 +000021#include "clang/AST/PrettyDeclStackTrace.h"
Chris Lattnerc8e630e2011-02-17 07:39:24 +000022#include "clang/AST/StmtCXX.h"
Benjamin Kramerf3ca26982014-05-10 16:31:55 +000023#include "clang/Basic/DiagnosticOptions.h"
Anders Carlssonf68079e2009-08-26 22:33:56 +000024#include "clang/Basic/PartialDiagnostic.h"
Chris Lattner7d4f5c42009-04-30 06:18:40 +000025#include "clang/Basic/TargetInfo.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000026#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"
Richard Smith7873de02016-08-11 22:25:46 +000031#include "clang/Sema/Initialization.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000032#include "clang/Sema/MultiplexExternalSemaSource.h"
33#include "clang/Sema/ObjCMethodList.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000034#include "clang/Sema/Scope.h"
35#include "clang/Sema/ScopeInfo.h"
36#include "clang/Sema/SemaConsumer.h"
Mehdi Amini9670f842016-07-18 19:02:11 +000037#include "clang/Sema/SemaInternal.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000038#include "clang/Sema/TemplateDeduction.h"
Gabor Horvath207e7b12018-02-10 14:04:45 +000039#include "clang/Sema/TemplateInstCallback.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000040#include "llvm/ADT/DenseMap.h"
41#include "llvm/ADT/SmallSet.h"
Anton Afanasyevd880de22019-03-30 08:42:48 +000042#include "llvm/Support/TimeProfiler.h"
43
Chris Lattnerc11438c2006-08-18 05:17:52 +000044using namespace clang;
John McCallaab3e412010-08-25 08:40:02 +000045using namespace sema;
Douglas Gregor9a28e842010-03-01 23:15:13 +000046
Alp Tokerb6cc5922014-05-03 03:45:55 +000047SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) {
48 return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
49}
50
51ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
52
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +000053PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
54 const Preprocessor &PP) {
Douglas Gregor75acd922011-09-27 23:30:47 +000055 PrintingPolicy Policy = Context.getPrintingPolicy();
Joel E. Denny7bcc2102018-05-14 18:41:44 +000056 // In diagnostics, we print _Bool as bool if the latter is defined as the
57 // former.
David Blaikiebbafb8a2012-03-11 07:00:24 +000058 Policy.Bool = Context.getLangOpts().Bool;
Douglas Gregor75acd922011-09-27 23:30:47 +000059 if (!Policy.Bool) {
Richard Smith301bc212016-05-19 01:39:10 +000060 if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
Michael Gottesmanbf0fd392013-01-20 01:04:14 +000061 Policy.Bool = BoolMacro->isObjectLike() &&
Richard Smith301bc212016-05-19 01:39:10 +000062 BoolMacro->getNumTokens() == 1 &&
63 BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
Douglas Gregor75acd922011-09-27 23:30:47 +000064 }
65 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +000066
Douglas Gregor75acd922011-09-27 23:30:47 +000067 return Policy;
68}
69
Douglas Gregorf11096c2010-08-25 18:07:12 +000070void Sema::ActOnTranslationUnitScope(Scope *S) {
Steve Naroffc62adb62007-10-09 22:01:59 +000071 TUScope = S;
Douglas Gregor91f84212008-12-11 16:49:14 +000072 PushDeclContext(S, Context.getTranslationUnitDecl());
Steve Naroff7f549f12007-10-10 21:53:07 +000073}
74
Alex Lorenz45b40142017-07-28 14:41:21 +000075namespace clang {
76namespace sema {
77
78class SemaPPCallbacks : public PPCallbacks {
79 Sema *S = nullptr;
80 llvm::SmallVector<SourceLocation, 8> IncludeStack;
81
82public:
83 void set(Sema &S) { this->S = &S; }
84
85 void reset() { S = nullptr; }
86
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()) {
Anton Afanasyevd880de22019-03-30 08:42:48 +000097 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
Alex Lorenz45b40142017-07-28 14:41:21 +0000103 IncludeStack.push_back(IncludeLoc);
104 S->DiagnoseNonDefaultPragmaPack(
105 Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc);
106 }
107 break;
108 }
109 case ExitFile:
Anton Afanasyevd880de22019-03-30 08:42:48 +0000110 if (!IncludeStack.empty()) {
111 if (llvm::timeTraceProfilerEnabled())
112 llvm::timeTraceProfilerEnd();
113
Alex Lorenz45b40142017-07-28 14:41:21 +0000114 S->DiagnoseNonDefaultPragmaPack(
115 Sema::PragmaPackDiagnoseKind::ChangedStateAtExit,
116 IncludeStack.pop_back_val());
Anton Afanasyevd880de22019-03-30 08:42:48 +0000117 }
Alex Lorenz45b40142017-07-28 14:41:21 +0000118 break;
119 default:
120 break;
121 }
122 }
123};
124
125} // end namespace sema
126} // end namespace clang
127
Douglas Gregor54feb842009-04-14 16:27:31 +0000128Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
Alex Lorenz9e7bf162017-04-18 14:33:39 +0000129 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),
Brian Gesiak3e65d9a2018-07-14 18:21:44 +0000145 StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
146 MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),
147 NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
Alex Lorenz9e7bf162017-04-18 14:33:39 +0000148 ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
149 ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
150 DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false),
Eric Fiselier0683c0e2018-05-07 21:07:10 +0000151 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),
Alex Lorenz9e7bf162017-04-18 14:33:39 +0000158 ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
159 CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
Craig Topperc3ec1492014-05-26 06:22:03 +0000160 TUScope = nullptr;
Gauthier Harnisch0bb4d462019-06-15 08:32:56 +0000161 isConstantEvaluatedOverride = false;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000162
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000163 LoadedExternalKnownNamespaces = false;
Ted Kremeneke65b0862012-03-06 20:05:56 +0000164 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
Craig Topperc3ec1492014-05-26 06:22:03 +0000165 NSNumberLiteralMethods[I] = nullptr;
Ted Kremeneke65b0862012-03-06 20:05:56 +0000166
Erik Pilkingtonfa983902018-10-30 20:31:30 +0000167 if (getLangOpts().ObjC)
Ted Kremeneke65b0862012-03-06 20:05:56 +0000168 NSAPIObj.reset(new NSAPI(Context));
169
David Blaikiebbafb8a2012-03-11 07:00:24 +0000170 if (getLangOpts().CPlusPlus)
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000171 FieldCollector.reset(new CXXFieldCollector());
Mike Stump11289f42009-09-09 15:08:12 +0000172
Chris Lattner6a2ed6f2008-11-23 09:13:29 +0000173 // Tell diagnostics how to render things from the AST library.
Craig Topper12126262015-11-15 17:27:57 +0000174 Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
Douglas Gregorff790f12009-11-26 00:44:06 +0000175
Faisal Valid143a0c2017-04-01 21:30:49 +0000176 ExprEvalContexts.emplace_back(
177 ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{},
Nicolas Lesserb6d5c582018-07-12 18:45:41 +0000178 nullptr, ExpressionEvaluationContextRecord::EK_Other);
John McCallaab3e412010-08-25 08:40:02 +0000179
Raphael Isemannb23ccec2018-12-10 12:37:46 +0000180 // Initialization of data sharing attributes stack for OpenMP
Alexey Bataev758e55e2013-09-06 18:03:48 +0000181 InitDataSharingAttributesStack();
Alex Lorenz45b40142017-07-28 14:41:21 +0000182
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);
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000188}
189
Alp Tokerf22856a2013-12-18 15:29:05 +0000190void 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
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000196void Sema::Initialize() {
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000197 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
198 SC->InitializeSema(*this);
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000199
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000200 // 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);
Douglas Gregor3ea72692011-08-12 05:46:01 +0000204
Ben Langmuirbb1c9182014-09-05 20:24:27 +0000205 // 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
Richard Smith33e0f7e2015-07-22 02:08:40 +0000209 if (!TUScope)
210 return;
211
Douglas Gregor801c99d2011-08-12 06:49:56 +0000212 // Initialize predefined 128-bit integer types, if needed.
Alp Tokerb6cc5922014-05-03 03:45:55 +0000213 if (Context.getTargetInfo().hasInt128Type()) {
Douglas Gregor801c99d2011-08-12 06:49:56 +0000214 // 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");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000217 if (IdResolver.begin(Int128) == IdResolver.end())
Douglas Gregor801c99d2011-08-12 06:49:56 +0000218 PushOnScopeChains(Context.getInt128Decl(), TUScope);
219
220 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000221 if (IdResolver.begin(UInt128) == IdResolver.end())
Douglas Gregor801c99d2011-08-12 06:49:56 +0000222 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
223 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000224
Douglas Gregor801c99d2011-08-12 06:49:56 +0000225
Douglas Gregor3ea72692011-08-12 05:46:01 +0000226 // Initialize predefined Objective-C types:
Erik Pilkingtonfa983902018-10-30 20:31:30 +0000227 if (getLangOpts().ObjC) {
Douglas Gregor52e02802011-08-12 06:17:30 +0000228 // If 'SEL' does not yet refer to any declarations, make it refer to the
229 // predefined 'SEL'.
230 DeclarationName SEL = &Context.Idents.get("SEL");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000231 if (IdResolver.begin(SEL) == IdResolver.end())
Douglas Gregor52e02802011-08-12 06:17:30 +0000232 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
233
Douglas Gregor3ea72692011-08-12 05:46:01 +0000234 // If 'id' does not yet refer to any declarations, make it refer to the
235 // predefined 'id'.
236 DeclarationName Id = &Context.Idents.get("id");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000237 if (IdResolver.begin(Id) == IdResolver.end())
Douglas Gregor3ea72692011-08-12 05:46:01 +0000238 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000239
Douglas Gregor0a586182011-08-12 05:59:41 +0000240 // Create the built-in typedef for 'Class'.
241 DeclarationName Class = &Context.Idents.get("Class");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000242 if (IdResolver.begin(Class) == IdResolver.end())
Douglas Gregor0a586182011-08-12 05:59:41 +0000243 PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
Douglas Gregord53ae832012-01-17 18:09:05 +0000244
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);
Douglas Gregor3ea72692011-08-12 05:46:01 +0000249 }
Meador Inge5d3fb222012-06-16 03:34:49 +0000250
Ben Langmuirf5416742016-02-04 00:55:24 +0000251 // 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
Alp Tokere1fab522014-01-04 15:25:02 +0000256 // Initialize Microsoft "predefined C++ types".
Craig Topper12126262015-11-15 17:27:57 +0000257 if (getLangOpts().MSVCCompat) {
258 if (getLangOpts().CPlusPlus &&
David Majnemerbe525392015-02-18 02:28:13 +0000259 IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
Alp Tokere1fab522014-01-04 15:25:02 +0000260 PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),
261 TUScope);
David Majnemer1de36912014-01-14 06:19:35 +0000262
263 addImplicitTypedef("size_t", Context.getSizeType());
Alp Tokere1fab522014-01-04 15:25:02 +0000264 }
265
Yaxun Liu5b746652016-12-18 05:18:55 +0000266 // Initialize predefined OpenCL types and supported extensions and (optional)
267 // core features.
Craig Topper12126262015-11-15 17:27:57 +0000268 if (getLangOpts().OpenCL) {
Anastasia Stulovae88e2b92019-02-07 17:32:37 +0000269 getOpenCLOptions().addSupport(
270 Context.getTargetInfo().getSupportedOpenCLOpts());
271 getOpenCLOptions().enableSupportedCore(getLangOpts());
Alp Tokerf22856a2013-12-18 15:29:05 +0000272 addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
273 addImplicitTypedef("event_t", Context.OCLEventTy);
Anastasia Stulovae88e2b92019-02-07 17:32:37 +0000274 if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
Alexey Bader9c8453f2015-09-15 11:18:52 +0000275 addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
276 addImplicitTypedef("queue_t", Context.OCLQueueTy);
Alexey Bader9c8453f2015-09-15 11:18:52 +0000277 addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000278 addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));
279 addImplicitTypedef("atomic_uint",
280 Context.getAtomicType(Context.UnsignedIntTy));
Yaxun Liu5b746652016-12-18 05:18:55 +0000281 auto AtomicLongT = Context.getAtomicType(Context.LongTy);
282 addImplicitTypedef("atomic_long", AtomicLongT);
283 auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
284 addImplicitTypedef("atomic_ulong", AtomicULongT);
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000285 addImplicitTypedef("atomic_float",
286 Context.getAtomicType(Context.FloatTy));
Yaxun Liu5b746652016-12-18 05:18:55 +0000287 auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
288 addImplicitTypedef("atomic_double", AtomicDoubleT);
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000289 // 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));
Yaxun Liu5b746652016-12-18 05:18:55 +0000292 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");
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000327 }
Yaxun Liu5b746652016-12-18 05:18:55 +0000328
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"
Andrew Savonichev3fee3512018-11-08 11:25:41 +0000334#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"
Yaxun Liu5b746652016-12-18 05:18:55 +0000338 };
Alp Tokerf22856a2013-12-18 15:29:05 +0000339
Craig Topper12126262015-11-15 17:27:57 +0000340 if (Context.getTargetInfo().hasBuiltinMSVaList()) {
Charles Davisc7d5c942015-09-17 20:55:33 +0000341 DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
342 if (IdResolver.begin(MSVaList) == IdResolver.end())
343 PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
344 }
345
Meador Inge5d3fb222012-06-16 03:34:49 +0000346 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
347 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
348 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
Steve Naroff38d31b42007-02-28 01:22:02 +0000349}
Chris Lattnercb6a3822006-11-10 06:20:45 +0000350
Anton Korobeynikov55bcea12010-01-10 12:58:08 +0000351Sema::~Sema() {
Eli Friedman570024a2010-08-05 06:57:20 +0000352 if (VisContext) FreeVisContext();
Reid Kleckner87a31802018-03-12 21:43:02 +0000353
John McCallaab3e412010-08-25 08:40:02 +0000354 // Kill all the active scopes.
Reid Kleckner87a31802018-03-12 21:43:02 +0000355 for (sema::FunctionScopeInfo *FSI : FunctionScopes)
Richard Smith2fdd95c2019-05-31 00:45:09 +0000356 delete FSI;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000357
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000358 // 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
Douglas Gregor6fd55e02010-08-13 03:15:25 +0000364 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000365 ExternalSema->ForgetSema();
Axel Naumanndd433f02012-10-18 19:05:02 +0000366
367 // If Sema's ExternalSource is the multiplexer - we own it.
368 if (isMultiplexExternalSource)
369 delete ExternalSource;
Alexey Bataev758e55e2013-09-06 18:03:48 +0000370
DeLesley Hutchinsab1dc2d2015-02-03 22:11:04 +0000371 threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);
372
Alexey Bataev758e55e2013-09-06 18:03:48 +0000373 // Destroys data sharing attributes stack for OpenMP
374 DestroyDataSharingAttributesStack();
Kaelyn Takataef3e42b2014-11-21 18:48:06 +0000375
Alex Lorenz45b40142017-07-28 14:41:21 +0000376 // Detach from the PP callback handler which outlives Sema since it's owned
377 // by the preprocessor.
378 SemaPPCallbackHandler->reset();
379
Kaelyn Takataef3e42b2014-11-21 18:48:06 +0000380 assert(DelayedTypos.empty() && "Uncorrected typos!");
Anton Korobeynikov55bcea12010-01-10 12:58:08 +0000381}
382
John McCall31168b02011-06-15 23:02:42 +0000383/// 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.
387bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
John McCallc6af8c62015-10-28 05:03:19 +0000388 UnavailableAttr::ImplicitReason reason) {
John McCall31168b02011-06-15 23:02:42 +0000389 // 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.
Richard Smith51ec0cf2017-02-21 01:17:38 +0000394 if (inTemplateInstantiation())
John McCall31168b02011-06-15 23:02:42 +0000395 return false;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000396
John McCall31168b02011-06-15 23:02:42 +0000397 // 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
John McCallc6af8c62015-10-28 05:03:19 +0000404 fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
John McCall31168b02011-06-15 23:02:42 +0000405 return true;
406}
407
Sebastian Redlab238a72011-04-24 16:28:06 +0000408ASTMutationListener *Sema::getASTMutationListener() const {
409 return getASTConsumer().GetASTMutationListener();
410}
411
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000412///Registers an external source. If an external source already exists,
Axel Naumanndd433f02012-10-18 19:05:02 +0000413/// creates a multiplex external source and appends to it.
414///
415///\param[in] E - A non-null external sema source.
416///
417void 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
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000433/// Print out statistics about the semantic analysis.
Chandler Carruthb4836ea2011-07-06 16:21:37 +0000434void 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
George Burgess IV8d141e02015-12-14 22:00:49 +0000442void 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
Nico Weberd7ba86b2017-05-05 16:11:08 +0000456void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {
Roman Lebedev809df342017-10-26 13:18:14 +0000457 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000458 E->getBeginLoc()))
Roman Lebedev809df342017-10-26 13:18:14 +0000459 return;
460 // nullptr only exists from C++11 on, so don't warn on its absence earlier.
461 if (!getLangOpts().CPlusPlus11)
462 return;
463
Nico Weberd7ba86b2017-05-05 16:11:08 +0000464 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
465 return;
Erich Keane818cf5b2017-10-25 20:23:13 +0000466 if (E->IgnoreParenImpCasts()->getType()->isNullPtrType())
Nico Weberd7ba86b2017-05-05 16:11:08 +0000467 return;
Roman Lebedev809df342017-10-26 13:18:14 +0000468
469 // If it is a macro from system header, and if the macro name is not "NULL",
470 // do not warn.
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000471 SourceLocation MaybeMacroLoc = E->getBeginLoc();
Roman Lebedev809df342017-10-26 13:18:14 +0000472 if (Diags.getSuppressSystemWarnings() &&
473 SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
474 !findMacroSpelling(MaybeMacroLoc, "NULL"))
Nico Weberd7ba86b2017-05-05 16:11:08 +0000475 return;
476
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000477 Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
Nico Weberd7ba86b2017-05-05 16:11:08 +0000478 << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
479}
480
Richard Smith507840d2011-11-29 22:48:16 +0000481/// 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.
484ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
485 CastKind Kind, ExprValueKind VK,
486 const CXXCastPath *BasePath,
487 CheckedConversionKind CCK) {
Richard Smith508ebf32011-10-28 03:31:48 +0000488#ifndef NDEBUG
489 if (VK == VK_RValue && !E->isRValue()) {
490 switch (Kind) {
491 default:
Craig Topperd8d43192014-06-18 05:13:13 +0000492 llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
493 "kind");
Richard Smith07ed9cf2019-06-20 19:49:13 +0000494 case CK_Dependent:
Richard Smith508ebf32011-10-28 03:31:48 +0000495 case CK_LValueToRValue:
496 case CK_ArrayToPointerDecay:
497 case CK_FunctionToPointerDecay:
498 case CK_ToVoid:
JF Bastien7d60a0f2018-07-18 18:01:41 +0000499 case CK_NonAtomicToAtomic:
Richard Smith508ebf32011-10-28 03:31:48 +0000500 break;
501 }
502 }
Richard Smith07ed9cf2019-06-20 19:49:13 +0000503 assert((VK == VK_RValue || Kind == CK_Dependent || !E->isRValue()) &&
504 "can't cast rvalue to lvalue");
Richard Smith508ebf32011-10-28 03:31:48 +0000505#endif
506
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000507 diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());
Nico Weberd7ba86b2017-05-05 16:11:08 +0000508 diagnoseZeroToNullptrConversion(Kind, E);
Douglas Gregorb4866e82015-06-19 18:13:19 +0000509
John Wiegley01296292011-04-08 18:41:53 +0000510 QualType ExprTy = Context.getCanonicalType(E->getType());
Mon P Wang74b32072008-09-04 08:38:01 +0000511 QualType TypeTy = Context.getCanonicalType(Ty);
Mike Stump11289f42009-09-09 15:08:12 +0000512
Mon P Wang74b32072008-09-04 08:38:01 +0000513 if (ExprTy == TypeTy)
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000514 return E;
Mike Stump11289f42009-09-09 15:08:12 +0000515
Richard Smithb3189a12016-12-05 07:49:14 +0000516 // 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
Richard Smith507840d2011-11-29 22:48:16 +0000528 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
529 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
530 ImpCast->setType(Ty);
531 ImpCast->setValueKind(VK);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000532 return E;
Richard Smith507840d2011-11-29 22:48:16 +0000533 }
534 }
535
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000536 return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
Sebastian Redlc57d34b2010-07-20 04:20:21 +0000537}
538
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000539/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
540/// to the conversion from scalar type ScalarTy to the Boolean type.
541CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
542 switch (ScalarTy->getScalarTypeKind()) {
543 case Type::STK_Bool: return CK_NoOp;
John McCall9320b872011-09-09 05:25:32 +0000544 case Type::STK_CPointer: return CK_PointerToBoolean;
545 case Type::STK_BlockPointer: return CK_PointerToBoolean;
546 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000547 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;
Leonard Chanb4ba4672018-10-23 17:55:35 +0000552 case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000553 }
Richard Smith354abec2017-12-08 23:29:59 +0000554 llvm_unreachable("unknown scalar type kind");
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000555}
556
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000557/// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000558static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
Rafael Espindola820fa702013-01-08 19:43:34 +0000559 if (D->getMostRecentDecl()->isUsed())
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000560 return true;
561
Rafael Espindola3ae00052013-05-13 00:12:11 +0000562 if (D->isExternallyVisible())
Rafael Espindola0e0d0092013-03-14 03:07:35 +0000563 return true;
564
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000565 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +0000566 // 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
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000573 // 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.
Douglas Gregorec9fd132012-01-14 16:38:05 +0000581 DeclToCheck = FD->getMostRecentDecl();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000582 if (DeclToCheck != FD)
583 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
584 }
585
586 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Eli Friedmana5dfebd2013-09-10 21:10:25 +0000587 // 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() &&
Richard Smith715f7a12019-06-11 17:50:32 +0000593 VD->mightBeUsableInConstantExpressions(SemaRef->Context))
Eli Friedmana5dfebd2013-09-10 21:10:25 +0000594 return true;
595
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +0000596 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
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000603 // UnusedFileScopedDecls stores the first declaration.
604 // The declaration may have become definition so check again.
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000605 const VarDecl *DeclToCheck = VD->getDefinition();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000606 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.
Douglas Gregorec9fd132012-01-14 16:38:05 +0000611 DeclToCheck = VD->getMostRecentDecl();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000612 if (DeclToCheck != VD)
613 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
614 }
615
616 return false;
617}
618
Richard Smith405e2db2017-09-20 07:22:00 +0000619static 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.
627bool 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
Richard Smith62f19e72016-06-25 00:15:56 +0000636/// Obtains a sorted list of functions and variables that are undefined but
637/// ODR-used.
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000638void Sema::getUndefinedButUsed(
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000639 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
Richard Smithd6a04d72016-03-25 21:49:43 +0000640 for (const auto &UndefinedUse : UndefinedButUsed) {
641 NamedDecl *ND = UndefinedUse.first;
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000642
643 // Ignore attributes that have become invalid.
644 if (ND->isInvalidDecl()) continue;
645
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000646 // __attribute__((weakref)) is basically a definition.
647 if (ND->hasAttr<WeakRefAttr>()) continue;
648
Richard Smith57865822017-08-03 19:24:27 +0000649 if (isa<CXXDeductionGuideDecl>(ND))
650 continue;
651
Richard Smith405e2db2017-09-20 07:22:00 +0000652 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
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000659 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
660 if (FD->isDefined())
661 continue;
Rafael Espindola3ae00052013-05-13 00:12:11 +0000662 if (FD->isExternallyVisible() &&
Richard Smith405e2db2017-09-20 07:22:00 +0000663 !isExternalWithNoLinkageType(FD) &&
Louis Dionned2695792018-10-04 15:49:42 +0000664 !FD->getMostRecentDecl()->isInlined() &&
665 !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000666 continue;
Reid Klecknerc8ae8782018-06-20 21:12:20 +0000667 if (FD->getBuiltinID())
668 continue;
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000669 } else {
Richard Smith62f19e72016-06-25 00:15:56 +0000670 auto *VD = cast<VarDecl>(ND);
671 if (VD->hasDefinition() != VarDecl::DeclarationOnly)
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000672 continue;
Richard Smith405e2db2017-09-20 07:22:00 +0000673 if (VD->isExternallyVisible() &&
674 !isExternalWithNoLinkageType(VD) &&
Louis Dionned2695792018-10-04 15:49:42 +0000675 !VD->getMostRecentDecl()->isInline() &&
676 !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000677 continue;
Justin Lebar5489f852018-05-17 16:15:07 +0000678
679 // Skip VarDecls that lack formal definitions but which we know are in
680 // fact defined somewhere.
681 if (VD->isKnownToBeDefined())
682 continue;
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000683 }
684
Richard Smithd6a04d72016-03-25 21:49:43 +0000685 Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000686 }
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000687}
688
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000689/// checkUndefinedButUsed - Check for undefined objects with internal linkage
690/// or that are inline.
691static void checkUndefinedButUsed(Sema &S) {
692 if (S.UndefinedButUsed.empty()) return;
John McCall83779672011-02-19 02:53:41 +0000693
694 // Collect all the still-undefined entities with internal linkage.
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000695 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000696 S.getUndefinedButUsed(Undefined);
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000697 if (Undefined.empty()) return;
John McCall83779672011-02-19 02:53:41 +0000698
Richard Smith405e2db2017-09-20 07:22:00 +0000699 for (auto Undef : Undefined) {
700 ValueDecl *VD = cast<ValueDecl>(Undef.first);
701 SourceLocation UseLoc = Undef.second;
John McCall83779672011-02-19 02:53:41 +0000702
Richard Smith405e2db2017-09-20 07:22:00 +0000703 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)) {
James Y Knight5b218ff2016-06-25 16:40:53 +0000724 (void)FD;
Richard Smith62f19e72016-06-25 00:15:56 +0000725 assert(FD->getMostRecentDecl()->isInlined() &&
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000726 "used object requires definition but isn't inline or internal?");
Richard Smith62f19e72016-06-25 00:15:56 +0000727 // FIXME: This is ill-formed; we should reject.
Richard Smith405e2db2017-09-20 07:22:00 +0000728 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
Richard Smith62f19e72016-06-25 00:15:56 +0000729 } else {
Richard Smith405e2db2017-09-20 07:22:00 +0000730 assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
Richard Smith62f19e72016-06-25 00:15:56 +0000731 "used var requires definition but isn't inline or internal?");
Richard Smith405e2db2017-09-20 07:22:00 +0000732 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000733 }
Richard Smith405e2db2017-09-20 07:22:00 +0000734 if (UseLoc.isValid())
735 S.Diag(UseLoc, diag::note_used_here);
John McCall83779672011-02-19 02:53:41 +0000736 }
Richard Smithd6a04d72016-03-25 21:49:43 +0000737
738 S.UndefinedButUsed.clear();
John McCall83779672011-02-19 02:53:41 +0000739}
740
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000741void Sema::LoadExternalWeakUndeclaredIdentifiers() {
742 if (!ExternalSource)
743 return;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000744
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000745 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
746 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
Chandler Carruthf85d9822015-03-26 08:32:49 +0000747 for (auto &WeakID : WeakIDs)
748 WeakUndeclaredIdentifiers.insert(WeakID);
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000749}
750
Daniel Jasper0baec5492012-06-06 08:32:04 +0000751
752typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
753
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000754/// Returns true, if all methods and nested classes of the given
Daniel Jasper0baec5492012-06-06 08:32:04 +0000755/// CXXRecordDecl are defined in this translation unit.
756///
757/// Should only be called from ActOnEndOfTranslationUnit so that all
758/// definitions are actually read.
759static 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))
Richard Smitha31174e2017-11-01 04:52:12 +0000771 Complete = M->isDefined() || M->isDefaulted() ||
772 (M->isPure() && !isa<CXXDestructorDecl>(M));
Daniel Jaspere99c2bf2012-06-14 20:56:06 +0000773 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
Nico Weber4bde6c22015-06-18 20:09:49 +0000774 // 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.
Ehsan Akhgari4b5ca9a2014-10-11 00:24:15 +0000778 Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
779 F->getTemplatedDecl()->isDefined();
Daniel Jasper0baec5492012-06-06 08:32:04 +0000780 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
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000794/// Returns true, if the given CXXRecordDecl is fully defined in this
Daniel Jasper0baec5492012-06-06 08:32:04 +0000795/// 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.
801static 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
Nico Weber72889432014-09-06 01:25:55 +0000832void 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
Richard Smithe03a6542017-07-05 01:42:07 +0000845/// 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.
848void Sema::ActOnStartOfTranslationUnit() {
Richard Smithac9f7fb2018-09-15 01:59:39 +0000849 if (getLangOpts().ModulesTS &&
850 (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
851 getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
Richard Smithd652bdd2019-04-14 08:06:59 +0000852 // We start in an implied global module fragment.
Richard Smithdd8b5332017-09-04 05:37:53 +0000853 SourceLocation StartOfTU =
854 SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
Richard Smithd652bdd2019-04-14 08:06:59 +0000855 ActOnGlobalModuleFragmentDecl(StartOfTU);
856 ModuleScopes.back().ImplicitGlobalModuleFragment = true;
Richard Smithe03a6542017-07-05 01:42:07 +0000857 }
858}
859
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000860void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) {
861 // No explicit actions are required at the end of the global module fragment.
862 if (Kind == TUFragmentKind::Global)
Douglas Gregorc459b512012-08-17 22:17:36 +0000863 return;
864
Reid Kleckner24bd88c2018-03-26 18:22:47 +0000865 // Transfer late parsed template instantiations over to the pending template
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000866 // instantiation list. During normal compilation, the late template parser
Reid Kleckner24bd88c2018-03-26 18:22:47 +0000867 // 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
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000879 // 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.
918void 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
Richard Smith0e5d7b82013-07-25 23:08:39 +0000927 // Complete translation units and modules define vtables and perform implicit
928 // instantiations. PCH files do not.
929 if (TUKind != TU_Prefix) {
Argyrios Kyrtzidisb6c6a582012-02-07 16:50:53 +0000930 DiagnoseUseOfUnimplementedSelectors();
931
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000932 ActOnEndOfTranslationUnitFragment(
933 !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
934 Module::PrivateModuleFragment
935 ? TUFragmentKind::Private
936 : TUFragmentKind::Normal);
Reid Kleckner24bd88c2018-03-26 18:22:47 +0000937
Reid Kleckner89bd8d62014-10-22 17:50:19 +0000938 if (LateTemplateParserCleanup)
939 LateTemplateParserCleanup(OpaqueParser);
940
Alp Tokerae3a9442013-10-18 05:54:19 +0000941 CheckDelayedMemberExceptionSpecs();
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000942 } 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();
Nick Lewyckyef4f4562010-11-25 00:35:20 +0000952 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000953
Alex Lorenz45b40142017-07-28 14:41:21 +0000954 DiagnoseUnterminatedPragmaPack();
Alex Lorenz9e7bf162017-04-18 14:33:39 +0000955 DiagnoseUnterminatedPragmaAttribute();
956
Alp Tokerae3a9442013-10-18 05:54:19 +0000957 // All delayed member exception specs should be checked or we end up accepting
958 // incompatible declarations.
Richard Smith5159bbad2018-09-05 22:30:37 +0000959 assert(DelayedOverridingExceptionSpecChecks.empty());
960 assert(DelayedEquivalentExceptionSpecChecks.empty());
Alp Tokerae3a9442013-10-18 05:54:19 +0000961
Hans Wennborg99000c22015-08-15 01:18:16 +0000962 // All dllexport classes should have been processed already.
963 assert(DelayedDllExportClasses.empty());
964
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +0000965 // Remove file scoped decls that turned out to be used.
Daniel Jasper9ba6f9b2013-04-30 06:43:16 +0000966 UnusedFileScopedDecls.erase(
Craig Topperc3ec1492014-05-26 06:22:03 +0000967 std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
Daniel Jasper9ba6f9b2013-04-30 06:43:16 +0000968 UnusedFileScopedDecls.end(),
Richard Smith2c27df72017-03-23 23:17:58 +0000969 [this](const DeclaratorDecl *DD) {
970 return ShouldRemoveFromUnused(this, DD);
971 }),
Daniel Jasper9ba6f9b2013-04-30 06:43:16 +0000972 UnusedFileScopedDecls.end());
Douglas Gregorfb8b27d2010-04-09 17:41:13 +0000973
Douglas Gregor69f74f82011-08-25 22:30:56 +0000974 if (TUKind == TU_Prefix) {
975 // Translation unit prefixes don't need any of the checking below.
Vassil Vassilev45bf62f2016-10-17 10:15:25 +0000976 if (!PP.isIncrementalProcessingEnabled())
977 TUScope = nullptr;
Argyrios Kyrtzidisee1afa32010-08-05 09:48:08 +0000978 return;
Douglas Gregorb14904c2010-08-13 22:48:40 +0000979 }
Argyrios Kyrtzidisee1afa32010-08-05 09:48:08 +0000980
Chris Lattner0c797362009-09-08 18:19:27 +0000981 // Check for #pragma weak identifiers that were never declared
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000982 LoadExternalWeakUndeclaredIdentifiers();
Chandler Carruthf85d9822015-03-26 08:32:49 +0000983 for (auto WeakID : WeakUndeclaredIdentifiers) {
984 if (WeakID.second.getUsed())
985 continue;
Mike Stump11289f42009-09-09 15:08:12 +0000986
Alexander Musmanfbbc0b82015-09-18 07:40:22 +0000987 Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
988 LookupOrdinaryName);
989 if (PrevDecl != nullptr &&
990 !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
991 Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
992 << "'weak'" << ExpectedVariableOrFunction;
993 else
994 Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
995 << WeakID.first;
Ryan Flynn7d470f32009-07-30 03:15:39 +0000996 }
997
Argyrios Kyrtzidisffb35582013-03-14 04:44:56 +0000998 if (LangOpts.CPlusPlus11 &&
Alp Tokerd4a3f0e2014-06-15 23:30:39 +0000999 !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
Argyrios Kyrtzidisffb35582013-03-14 04:44:56 +00001000 CheckDelegatingCtorCycles();
1001
Richard Smithd6a04d72016-03-25 21:49:43 +00001002 if (!Diags.hasErrorOccurred()) {
1003 if (ExternalSource)
1004 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
1005 checkUndefinedButUsed(*this);
1006 }
1007
Richard Smithd652bdd2019-04-14 08:06:59 +00001008 // A global-module-fragment is only permitted within a module unit.
1009 bool DiagnosedMissingModuleDeclaration = false;
1010 if (!ModuleScopes.empty() &&
1011 ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment &&
1012 !ModuleScopes.back().ImplicitGlobalModuleFragment) {
1013 Diag(ModuleScopes.back().BeginLoc,
1014 diag::err_module_declaration_missing_after_global_module_introducer);
1015 DiagnosedMissingModuleDeclaration = true;
1016 }
1017
Douglas Gregor69f74f82011-08-25 22:30:56 +00001018 if (TUKind == TU_Module) {
Richard Smith18057cb2017-10-11 00:36:56 +00001019 // If we are building a module interface unit, we need to have seen the
1020 // module declaration by now.
1021 if (getLangOpts().getCompilingModule() ==
1022 LangOptions::CMK_ModuleInterface &&
Richard Smithd6509cf2018-09-15 01:21:15 +00001023 (ModuleScopes.empty() ||
Richard Smitha5bbbfe2019-04-18 21:12:54 +00001024 !ModuleScopes.back().Module->isModulePurview()) &&
Richard Smithd652bdd2019-04-14 08:06:59 +00001025 !DiagnosedMissingModuleDeclaration) {
Richard Smith18057cb2017-10-11 00:36:56 +00001026 // FIXME: Make a better guess as to where to put the module declaration.
1027 Diag(getSourceManager().getLocForStartOfFile(
1028 getSourceManager().getMainFileID()),
1029 diag::err_module_declaration_missing);
1030 }
1031
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001032 // If we are building a module, resolve all of the exported declarations
1033 // now.
1034 if (Module *CurrentModule = PP.getCurrentModule()) {
1035 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001036
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001037 SmallVector<Module *, 2> Stack;
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001038 Stack.push_back(CurrentModule);
1039 while (!Stack.empty()) {
Robert Wilhelm25284cc2013-08-23 16:11:15 +00001040 Module *Mod = Stack.pop_back_val();
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001041
Douglas Gregorfb912652013-03-20 21:10:35 +00001042 // Resolve the exported declarations and conflicts.
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001043 // FIXME: Actually complain, once we figure out how to teach the
Douglas Gregorfb912652013-03-20 21:10:35 +00001044 // diagnostic client to deal with complaints in the module map at this
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001045 // point.
1046 ModMap.resolveExports(Mod, /*Complain=*/false);
Daniel Jasperba7f2f72013-09-24 09:14:14 +00001047 ModMap.resolveUses(Mod, /*Complain=*/false);
Douglas Gregorfb912652013-03-20 21:10:35 +00001048 ModMap.resolveConflicts(Mod, /*Complain=*/false);
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001049
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001050 // Queue the submodules, so their exports will also be resolved.
Benjamin Kramerf367dd92015-06-12 15:31:50 +00001051 Stack.append(Mod->submodule_begin(), Mod->submodule_end());
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001052 }
1053 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001054
Nico Weber72889432014-09-06 01:25:55 +00001055 // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1056 // modules when they are built, not every time they are used.
1057 emitAndClearUnusedLocalTypedefWarnings();
Douglas Gregor69f74f82011-08-25 22:30:56 +00001058 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001059
Douglas Gregor0760fa12009-03-10 23:43:53 +00001060 // C99 6.9.2p2:
1061 // A declaration of an identifier for an object that has file
1062 // scope without an initializer, and without a storage-class
1063 // specifier or with the storage-class specifier static,
1064 // constitutes a tentative definition. If a translation unit
1065 // contains one or more tentative definitions for an identifier,
1066 // and the translation unit contains no external definition for
1067 // that identifier, then the behavior is exactly as if the
1068 // translation unit contains a file scope declaration of that
1069 // identifier, with the composite type as of the end of the
1070 // translation unit, with an initializer equal to 0.
Sebastian Redl35351a92010-01-31 22:27:38 +00001071 llvm::SmallSet<VarDecl *, 32> Seen;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001072 for (TentativeDefinitionsType::iterator
Douglas Gregoreb08bd42011-07-27 20:58:46 +00001073 T = TentativeDefinitions.begin(ExternalSource),
1074 TEnd = TentativeDefinitions.end();
Richard Smithf5262c62018-06-28 01:57:04 +00001075 T != TEnd; ++T) {
Douglas Gregoreb08bd42011-07-27 20:58:46 +00001076 VarDecl *VD = (*T)->getActingDefinition();
Mike Stump11289f42009-09-09 15:08:12 +00001077
Sebastian Redl35351a92010-01-31 22:27:38 +00001078 // If the tentative definition was completed, getActingDefinition() returns
1079 // null. If we've already seen this variable before, insert()'s second
1080 // return value is false.
David Blaikie82e95a32014-11-19 07:49:47 +00001081 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
Douglas Gregorbeecd582009-04-21 17:11:58 +00001082 continue;
1083
Mike Stump11289f42009-09-09 15:08:12 +00001084 if (const IncompleteArrayType *ArrayT
Douglas Gregorbeecd582009-04-21 17:11:58 +00001085 = Context.getAsIncompleteArrayType(VD->getType())) {
Chris Lattner0c797362009-09-08 18:19:27 +00001086 // Set the length of the array to 1 (C99 6.9.2p5).
1087 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1088 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
John McCallc5b82252009-10-16 00:14:28 +00001089 QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
1090 One, ArrayType::Normal, 0);
Chris Lattner0c797362009-09-08 18:19:27 +00001091 VD->setType(T);
Mike Stump11289f42009-09-09 15:08:12 +00001092 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
Douglas Gregorbeecd582009-04-21 17:11:58 +00001093 diag::err_tentative_def_incomplete_type))
1094 VD->setInvalidDecl();
1095
Richard Smith7873de02016-08-11 22:25:46 +00001096 // No initialization is performed for a tentative definition.
Richard Smith3997b1b2016-08-12 01:55:21 +00001097 CheckCompleteVariableDeclaration(VD);
Eli Friedman7d14b3c2012-10-23 20:19:32 +00001098
Douglas Gregorbeecd582009-04-21 17:11:58 +00001099 // Notify the consumer that we've completed a tentative definition.
1100 if (!VD->isInvalidDecl())
1101 Consumer.CompleteTentativeDefinition(VD);
Douglas Gregor0760fa12009-03-10 23:43:53 +00001102 }
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001103
1104 // If there were errors, disable 'unused' warnings since they will mostly be
Richard Smithf5262c62018-06-28 01:57:04 +00001105 // noise. Don't warn for a use from a module: either we should warn on all
1106 // file-scope declarations in modules or not at all, but whether the
1107 // declaration is used is immaterial.
1108 if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001109 // Output warning for unused file scoped decls.
Douglas Gregora94a1542011-07-27 21:45:57 +00001110 for (UnusedFileScopedDeclsType::iterator
1111 I = UnusedFileScopedDecls.begin(ExternalSource),
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001112 E = UnusedFileScopedDecls.end(); I != E; ++I) {
Douglas Gregora94a1542011-07-27 21:45:57 +00001113 if (ShouldRemoveFromUnused(this, *I))
1114 continue;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001115
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001116 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1117 const FunctionDecl *DiagD;
1118 if (!FD->hasBody(DiagD))
1119 DiagD = FD;
Argyrios Kyrtzidise0283142011-03-03 17:47:42 +00001120 if (DiagD->isDeleted())
1121 continue; // Deleted functions are supposed to be unused.
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001122 if (DiagD->isReferenced()) {
1123 if (isa<CXXMethodDecl>(DiagD))
1124 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1125 << DiagD->getDeclName();
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001126 else {
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001127 if (FD->getStorageClass() == SC_Static &&
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001128 !FD->isInlineSpecified() &&
Eli Friedman5ba37d52013-08-22 00:27:10 +00001129 !SourceMgr.isInMainFile(
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001130 SourceMgr.getExpansionLoc(FD->getLocation())))
Nico Weber63816332014-07-26 23:20:08 +00001131 Diag(DiagD->getLocation(),
1132 diag::warn_unneeded_static_internal_decl)
1133 << DiagD->getDeclName();
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001134 else
1135 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1136 << /*function*/0 << DiagD->getDeclName();
1137 }
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001138 } else {
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +00001139 if (FD->getDescribedFunctionTemplate())
1140 Diag(DiagD->getLocation(), diag::warn_unused_template)
1141 << /*function*/0 << DiagD->getDeclName();
1142 else
1143 Diag(DiagD->getLocation(),
1144 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1145 : diag::warn_unused_function)
1146 << DiagD->getDeclName();
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001147 }
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001148 } else {
1149 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1150 if (!DiagD)
1151 DiagD = cast<VarDecl>(*I);
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001152 if (DiagD->isReferenced()) {
1153 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1154 << /*variable*/1 << DiagD->getDeclName();
Daniel Jasperc531dae2013-09-11 10:37:35 +00001155 } else if (DiagD->getType().isConstQualified()) {
Erik Verbruggen89aa7eb2016-10-28 08:28:42 +00001156 const SourceManager &SM = SourceMgr;
1157 if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1158 !PP.getLangOpts().IsHeaderFile)
1159 Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1160 << DiagD->getDeclName();
Eli Friedman5ef21752013-09-10 03:05:56 +00001161 } else {
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +00001162 if (DiagD->getDescribedVarTemplate())
1163 Diag(DiagD->getLocation(), diag::warn_unused_template)
1164 << /*variable*/1 << DiagD->getDeclName();
1165 else
1166 Diag(DiagD->getLocation(), diag::warn_unused_variable)
Matt Beaumont-Gaye1368a12013-04-10 00:47:10 +00001167 << DiagD->getDeclName();
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001168 }
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001169 }
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001170 }
John McCall83779672011-02-19 02:53:41 +00001171
Nico Weber72889432014-09-06 01:25:55 +00001172 emitAndClearUnusedLocalTypedefWarnings();
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +00001173 }
Douglas Gregorb14904c2010-08-13 22:48:40 +00001174
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00001175 if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
Richard Smithf5262c62018-06-28 01:57:04 +00001176 // FIXME: Load additional unused private field candidates from the external
1177 // source.
Daniel Jasper0baec5492012-06-06 08:32:04 +00001178 RecordCompleteMap RecordsComplete;
1179 RecordCompleteMap MNCComplete;
1180 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1181 E = UnusedPrivateFields.end(); I != E; ++I) {
1182 const NamedDecl *D = *I;
1183 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1184 if (RD && !RD->isUnion() &&
1185 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1186 Diag(D->getLocation(), diag::warn_unused_private_field)
1187 << D->getDeclName();
1188 }
1189 }
1190 }
1191
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00001192 if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1193 if (ExternalSource)
1194 ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs);
1195 for (const auto &DeletedFieldInfo : DeleteExprs) {
1196 for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1197 AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1198 DeleteExprLoc.second);
1199 }
1200 }
1201 }
1202
Richard Smithb2bc2e62011-02-21 20:05:19 +00001203 // Check we've noticed that we're no longer parsing the initializer for every
1204 // variable. If we miss cases, then at best we have a performance issue and
1205 // at worst a rejects-valid bug.
1206 assert(ParsingInitForAutoVars.empty() &&
1207 "Didn't unmark var as having its initializer parsed");
1208
Vassil Vassilev45bf62f2016-10-17 10:15:25 +00001209 if (!PP.isIncrementalProcessingEnabled())
1210 TUScope = nullptr;
Chris Lattnerf4404402008-08-23 03:19:52 +00001211}
1212
1213
Chris Lattnerc11438c2006-08-18 05:17:52 +00001214//===----------------------------------------------------------------------===//
Chris Lattnereaafe1222006-11-10 05:17:58 +00001215// Helper functions.
1216//===----------------------------------------------------------------------===//
1217
Anders Carlssonb26ab812009-08-08 17:45:02 +00001218DeclContext *Sema::getFunctionLevelDeclContext() {
John McCallb8788012009-12-19 10:53:49 +00001219 DeclContext *DC = CurContext;
Mike Stump11289f42009-09-09 15:08:12 +00001220
Eli Friedman73a04092012-01-07 04:59:52 +00001221 while (true) {
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00001222 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
Eli Friedman73a04092012-01-07 04:59:52 +00001223 DC = DC->getParent();
1224 } else if (isa<CXXMethodDecl>(DC) &&
Douglas Gregor1a22d282012-02-12 17:34:23 +00001225 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
Eli Friedman73a04092012-01-07 04:59:52 +00001226 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1227 DC = DC->getParent()->getParent();
1228 }
1229 else break;
1230 }
Mike Stump11289f42009-09-09 15:08:12 +00001231
Anders Carlssonb26ab812009-08-08 17:45:02 +00001232 return DC;
1233}
1234
Chris Lattner79413952008-12-04 23:50:19 +00001235/// getCurFunctionDecl - If inside of a function body, this returns a pointer
1236/// to the function decl for the function being parsed. If we're currently
1237/// in a 'block', this returns the containing context.
1238FunctionDecl *Sema::getCurFunctionDecl() {
Anders Carlssonb26ab812009-08-08 17:45:02 +00001239 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner79413952008-12-04 23:50:19 +00001240 return dyn_cast<FunctionDecl>(DC);
1241}
1242
Daniel Dunbar6e8aa532008-08-11 05:35:13 +00001243ObjCMethodDecl *Sema::getCurMethodDecl() {
Anders Carlssonb26ab812009-08-08 17:45:02 +00001244 DeclContext *DC = getFunctionLevelDeclContext();
Fariborz Jahaniandeac9ac2013-05-31 21:51:12 +00001245 while (isa<RecordDecl>(DC))
1246 DC = DC->getParent();
Steve Naroffecf2bb82008-11-17 16:28:52 +00001247 return dyn_cast<ObjCMethodDecl>(DC);
Daniel Dunbar6e8aa532008-08-11 05:35:13 +00001248}
Chris Lattner79413952008-12-04 23:50:19 +00001249
1250NamedDecl *Sema::getCurFunctionOrMethodDecl() {
Anders Carlssonb26ab812009-08-08 17:45:02 +00001251 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner79413952008-12-04 23:50:19 +00001252 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
Douglas Gregor6e6ad602009-01-20 01:17:11 +00001253 return cast<NamedDecl>(DC);
Craig Topperc3ec1492014-05-26 06:22:03 +00001254 return nullptr;
Chris Lattner79413952008-12-04 23:50:19 +00001255}
1256
Daniel Dunbard671ab92012-03-14 09:49:32 +00001257void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1258 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1259 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1260 // been made more painfully obvious by the refactor that introduced this
1261 // function, but it is possible that the incoming argument can be
Richard Smith51ec0cf2017-02-21 01:17:38 +00001262 // eliminated. If it truly cannot be (for example, there is some reentrancy
Daniel Dunbard671ab92012-03-14 09:49:32 +00001263 // issue I am not seeing yet), then there should at least be a clarifying
1264 // comment somewhere.
David Blaikie05785d12013-02-20 22:23:23 +00001265 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
Daniel Dunbard671ab92012-03-14 09:49:32 +00001266 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
1267 Diags.getCurrentDiagID())) {
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00001268 case DiagnosticIDs::SFINAE_Report:
Richard Smith38c0e042011-10-19 00:07:01 +00001269 // We'll report the diagnostic below.
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001270 break;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001271
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00001272 case DiagnosticIDs::SFINAE_SubstitutionFailure:
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001273 // Count this failure so that we know that template argument deduction
1274 // has failed.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001275 ++NumSFINAEErrors;
Richard Smith9ca64612012-05-07 09:03:25 +00001276
1277 // Make a copy of this suppressed diagnostic and store it with the
1278 // template-deduction information.
1279 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1280 Diagnostic DiagInfo(&Diags);
1281 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1282 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1283 }
1284
Daniel Dunbard671ab92012-03-14 09:49:32 +00001285 Diags.setLastDiagnosticIgnored();
1286 Diags.Clear();
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001287 return;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001288
Richard Smith38c0e042011-10-19 00:07:01 +00001289 case DiagnosticIDs::SFINAE_AccessControl: {
1290 // Per C++ Core Issue 1170, access control is part of SFINAE.
Daniel Dunbara25002f2012-03-13 18:30:54 +00001291 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
Richard Smith38c0e042011-10-19 00:07:01 +00001292 // make access control a part of SFINAE for the purposes of checking
1293 // type traits.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001294 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
Richard Smith38c0e042011-10-19 00:07:01 +00001295 break;
1296
Daniel Dunbard671ab92012-03-14 09:49:32 +00001297 SourceLocation Loc = Diags.getCurrentDiagLoc();
Richard Smith38c0e042011-10-19 00:07:01 +00001298
1299 // Suppress this diagnostic.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001300 ++NumSFINAEErrors;
Richard Smith9ca64612012-05-07 09:03:25 +00001301
1302 // Make a copy of this suppressed diagnostic and store it with the
1303 // template-deduction information.
1304 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1305 Diagnostic DiagInfo(&Diags);
1306 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1307 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1308 }
1309
Daniel Dunbard671ab92012-03-14 09:49:32 +00001310 Diags.setLastDiagnosticIgnored();
1311 Diags.Clear();
Richard Smith38c0e042011-10-19 00:07:01 +00001312
1313 // Now the diagnostic state is clear, produce a C++98 compatibility
1314 // warning.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001315 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
Richard Smith38c0e042011-10-19 00:07:01 +00001316
1317 // The last diagnostic which Sema produced was ignored. Suppress any
1318 // notes attached to it.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001319 Diags.setLastDiagnosticIgnored();
Richard Smith38c0e042011-10-19 00:07:01 +00001320 return;
1321 }
1322
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00001323 case DiagnosticIDs::SFINAE_Suppress:
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001324 // Make a copy of this suppressed diagnostic and store it with the
1325 // template-deduction information;
Richard Smith9ca64612012-05-07 09:03:25 +00001326 if (*Info) {
1327 Diagnostic DiagInfo(&Diags);
Douglas Gregoredb76852011-01-27 22:31:44 +00001328 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
Richard Smith9ca64612012-05-07 09:03:25 +00001329 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1330 }
1331
1332 // Suppress this diagnostic.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001333 Diags.setLastDiagnosticIgnored();
1334 Diags.Clear();
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001335 return;
1336 }
1337 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001338
Joel E. Denny7bcc2102018-05-14 18:41:44 +00001339 // Copy the diagnostic printing policy over the ASTContext printing policy.
1340 // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
Daniel Dunbard671ab92012-03-14 09:49:32 +00001341 Context.setPrintingPolicy(getPrintingPolicy());
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001342
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001343 // Emit the diagnostic.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001344 if (!Diags.EmitCurrentDiagnostic())
Douglas Gregor33834512009-06-14 07:33:30 +00001345 return;
Mike Stump11289f42009-09-09 15:08:12 +00001346
Douglas Gregorda17bd32009-03-20 22:48:49 +00001347 // If this is not a note, and we're in a template instantiation
1348 // that is different from the last template instantiation where
1349 // we emitted an error, print a template instantiation
1350 // backtrace.
Richard Smith51ec0cf2017-02-21 01:17:38 +00001351 if (!DiagnosticIDs::isBuiltinNote(DiagID))
1352 PrintContextStack();
Douglas Gregorda17bd32009-03-20 22:48:49 +00001353}
Douglas Gregorc6d5edd2009-07-02 17:08:52 +00001354
Anders Carlssonf68079e2009-08-26 22:33:56 +00001355Sema::SemaDiagnosticBuilder
1356Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
1357 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1358 PD.Emit(Builder);
Mike Stump11289f42009-09-09 15:08:12 +00001359
Anders Carlssonf68079e2009-08-26 22:33:56 +00001360 return Builder;
1361}
1362
Alexey Bataev89721332019-02-07 19:46:42 +00001363// Print notes showing how we can reach FD starting from an a priori
1364// known-callable function.
1365static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
1366 auto FnIt = S.DeviceKnownEmittedFns.find(FD);
1367 while (FnIt != S.DeviceKnownEmittedFns.end()) {
1368 DiagnosticBuilder Builder(
1369 S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
1370 Builder << FnIt->second.FD;
1371 Builder.setForceEmit();
1372
1373 FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
1374 }
1375}
1376
1377// Emit any deferred diagnostics for FD and erase them from the map in which
1378// they're stored.
1379static void emitDeferredDiags(Sema &S, FunctionDecl *FD) {
1380 auto It = S.DeviceDeferredDiags.find(FD);
1381 if (It == S.DeviceDeferredDiags.end())
1382 return;
1383 bool HasWarningOrError = false;
1384 for (PartialDiagnosticAt &PDAt : It->second) {
1385 const SourceLocation &Loc = PDAt.first;
1386 const PartialDiagnostic &PD = PDAt.second;
1387 HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
1388 PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
1389 DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
1390 Builder.setForceEmit();
1391 PD.Emit(Builder);
1392 }
1393 S.DeviceDeferredDiags.erase(It);
1394
1395 // FIXME: Should this be called after every warning/error emitted in the loop
1396 // above, instead of just once per function? That would be consistent with
1397 // how we handle immediate errors, but it also seems like a bit much.
1398 if (HasWarningOrError)
1399 emitCallStackNotes(S, FD);
1400}
1401
1402// In CUDA, there are some constructs which may appear in semantically-valid
1403// code, but trigger errors if we ever generate code for the function in which
1404// they appear. Essentially every construct you're not allowed to use on the
1405// device falls into this category, because you are allowed to use these
1406// constructs in a __host__ __device__ function, but only if that function is
1407// never codegen'ed on the device.
1408//
1409// To handle semantic checking for these constructs, we keep track of the set of
1410// functions we know will be emitted, either because we could tell a priori that
1411// they would be emitted, or because they were transitively called by a
1412// known-emitted function.
1413//
1414// We also keep a partial call graph of which not-known-emitted functions call
1415// which other not-known-emitted functions.
1416//
1417// When we see something which is illegal if the current function is emitted
1418// (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
1419// CheckCUDACall), we first check if the current function is known-emitted. If
1420// so, we immediately output the diagnostic.
1421//
1422// Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags
1423// until we discover that the function is known-emitted, at which point we take
1424// it out of this map and emit the diagnostic.
1425
1426Sema::DeviceDiagBuilder::DeviceDiagBuilder(Kind K, SourceLocation Loc,
1427 unsigned DiagID, FunctionDecl *Fn,
1428 Sema &S)
1429 : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
1430 ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
1431 switch (K) {
1432 case K_Nop:
1433 break;
1434 case K_Immediate:
1435 case K_ImmediateWithCallStack:
1436 ImmediateDiag.emplace(S.Diag(Loc, DiagID));
1437 break;
1438 case K_Deferred:
1439 assert(Fn && "Must have a function to attach the deferred diag to.");
Alexey Bataev3167b302019-02-22 14:42:48 +00001440 auto &Diags = S.DeviceDeferredDiags[Fn];
1441 PartialDiagId.emplace(Diags.size());
1442 Diags.emplace_back(Loc, S.PDiag(DiagID));
Alexey Bataev89721332019-02-07 19:46:42 +00001443 break;
1444 }
1445}
1446
Alexey Bataeve69f94e2019-02-22 20:36:10 +00001447Sema::DeviceDiagBuilder::DeviceDiagBuilder(DeviceDiagBuilder &&D)
1448 : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),
1449 ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),
1450 PartialDiagId(D.PartialDiagId) {
1451 // Clean the previous diagnostics.
1452 D.ShowCallStack = false;
1453 D.ImmediateDiag.reset();
1454 D.PartialDiagId.reset();
1455}
1456
Alexey Bataev89721332019-02-07 19:46:42 +00001457Sema::DeviceDiagBuilder::~DeviceDiagBuilder() {
1458 if (ImmediateDiag) {
1459 // Emit our diagnostic and, if it was a warning or error, output a callstack
1460 // if Fn isn't a priori known-emitted.
1461 bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
1462 DiagID, Loc) >= DiagnosticsEngine::Warning;
1463 ImmediateDiag.reset(); // Emit the immediate diag.
1464 if (IsWarningOrError && ShowCallStack)
1465 emitCallStackNotes(S, Fn);
Alexey Bataev3167b302019-02-22 14:42:48 +00001466 } else {
1467 assert((!PartialDiagId || ShowCallStack) &&
1468 "Must always show call stack for deferred diags.");
Alexey Bataev89721332019-02-07 19:46:42 +00001469 }
1470}
1471
1472// Indicate that this function (and thus everything it transtively calls) will
1473// be codegen'ed, and emit any deferred diagnostics on this function and its
1474// (transitive) callees.
1475void Sema::markKnownEmitted(
1476 Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
1477 SourceLocation OrigLoc,
1478 const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted) {
1479 // Nothing to do if we already know that FD is emitted.
1480 if (IsKnownEmitted(S, OrigCallee)) {
1481 assert(!S.DeviceCallGraph.count(OrigCallee));
1482 return;
1483 }
1484
1485 // We've just discovered that OrigCallee is known-emitted. Walk our call
1486 // graph to see what else we can now discover also must be emitted.
1487
1488 struct CallInfo {
1489 FunctionDecl *Caller;
1490 FunctionDecl *Callee;
1491 SourceLocation Loc;
1492 };
1493 llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
1494 llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
1495 Seen.insert(OrigCallee);
1496 while (!Worklist.empty()) {
1497 CallInfo C = Worklist.pop_back_val();
1498 assert(!IsKnownEmitted(S, C.Callee) &&
1499 "Worklist should not contain known-emitted functions.");
1500 S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
1501 emitDeferredDiags(S, C.Callee);
1502
1503 // If this is a template instantiation, explore its callgraph as well:
1504 // Non-dependent calls are part of the template's callgraph, while dependent
1505 // calls are part of to the instantiation's call graph.
1506 if (auto *Templ = C.Callee->getPrimaryTemplate()) {
1507 FunctionDecl *TemplFD = Templ->getAsFunction();
1508 if (!Seen.count(TemplFD) && !S.DeviceKnownEmittedFns.count(TemplFD)) {
1509 Seen.insert(TemplFD);
1510 Worklist.push_back(
1511 {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
1512 }
1513 }
1514
1515 // Add all functions called by Callee to our worklist.
1516 auto CGIt = S.DeviceCallGraph.find(C.Callee);
1517 if (CGIt == S.DeviceCallGraph.end())
1518 continue;
1519
1520 for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
1521 CGIt->second) {
1522 FunctionDecl *NewCallee = FDLoc.first;
1523 SourceLocation CallLoc = FDLoc.second;
1524 if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
1525 continue;
1526 Seen.insert(NewCallee);
1527 Worklist.push_back(
1528 {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
1529 }
1530
1531 // C.Callee is now known-emitted, so we no longer need to maintain its list
1532 // of callees in DeviceCallGraph.
1533 S.DeviceCallGraph.erase(CGIt);
1534 }
1535}
1536
Alexey Bataev3167b302019-02-22 14:42:48 +00001537Sema::DeviceDiagBuilder Sema::targetDiag(SourceLocation Loc, unsigned DiagID) {
Alexey Bataev5c96c1c2019-02-20 17:42:57 +00001538 if (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)
1539 return diagIfOpenMPDeviceCode(Loc, DiagID);
Alexey Bataev3167b302019-02-22 14:42:48 +00001540 if (getLangOpts().CUDA)
1541 return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID)
1542 : CUDADiagIfHostCode(Loc, DiagID);
Alexey Bataev5c96c1c2019-02-20 17:42:57 +00001543 return DeviceDiagBuilder(DeviceDiagBuilder::K_Immediate, Loc, DiagID,
1544 getCurFunctionDecl(), *this);
1545}
1546
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001547/// Looks through the macro-expansion chain for the given
Chandler Carruthc22845a2011-07-26 05:40:03 +00001548/// location, looking for a macro expansion with the given name.
John McCall462c0552011-03-08 07:59:04 +00001549/// If one is found, returns true and sets the location to that
Chandler Carruthc22845a2011-07-26 05:40:03 +00001550/// expansion loc.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001551bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
John McCall462c0552011-03-08 07:59:04 +00001552 SourceLocation loc = locref;
1553 if (!loc.isMacroID()) return false;
1554
1555 // There's no good way right now to look at the intermediate
Chandler Carruthc22845a2011-07-26 05:40:03 +00001556 // expansions, so just jump to the expansion location.
Chandler Carruth35f53202011-07-25 16:49:02 +00001557 loc = getSourceManager().getExpansionLoc(loc);
John McCall462c0552011-03-08 07:59:04 +00001558
1559 // If that's written with the name, stop here.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001560 SmallVector<char, 16> buffer;
John McCall462c0552011-03-08 07:59:04 +00001561 if (getPreprocessor().getSpelling(loc, buffer) == name) {
1562 locref = loc;
1563 return true;
1564 }
1565 return false;
1566}
1567
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001568/// Determines the active Scope associated with the given declaration
Douglas Gregor0be31a22010-07-02 17:43:08 +00001569/// context.
1570///
1571/// This routine maps a declaration context to the active Scope object that
1572/// represents that declaration context in the parser. It is typically used
1573/// from "scope-less" code (e.g., template instantiation, lazy creation of
1574/// declarations) that injects a name for name-lookup purposes and, therefore,
1575/// must update the Scope.
1576///
1577/// \returns The scope corresponding to the given declaraion context, or NULL
1578/// if no such scope is open.
1579Scope *Sema::getScopeForContext(DeclContext *Ctx) {
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001580
Douglas Gregor0be31a22010-07-02 17:43:08 +00001581 if (!Ctx)
Craig Topperc3ec1492014-05-26 06:22:03 +00001582 return nullptr;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001583
Douglas Gregor0be31a22010-07-02 17:43:08 +00001584 Ctx = Ctx->getPrimaryContext();
1585 for (Scope *S = getCurScope(); S; S = S->getParent()) {
Sebastian Redlcaef9ab2010-07-08 23:07:34 +00001586 // Ignore scopes that cannot have declarations. This is important for
1587 // out-of-line definitions of static class members.
1588 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
Ted Kremenekc37877d2013-10-08 17:08:03 +00001589 if (DeclContext *Entity = S->getEntity())
Sebastian Redlcaef9ab2010-07-08 23:07:34 +00001590 if (Ctx == Entity->getPrimaryContext())
1591 return S;
Douglas Gregor0be31a22010-07-02 17:43:08 +00001592 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001593
Craig Topperc3ec1492014-05-26 06:22:03 +00001594 return nullptr;
Douglas Gregor0be31a22010-07-02 17:43:08 +00001595}
Douglas Gregor9a28e842010-03-01 23:15:13 +00001596
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001597/// Enter a new function scope
Douglas Gregor9a28e842010-03-01 23:15:13 +00001598void Sema::PushFunctionScope() {
Richard Smith2fdd95c2019-05-31 00:45:09 +00001599 if (FunctionScopes.empty() && CachedFunctionScope) {
1600 // Use CachedFunctionScope to avoid allocating memory when possible.
1601 CachedFunctionScope->Clear();
1602 FunctionScopes.push_back(CachedFunctionScope.release());
Reid Kleckner87a31802018-03-12 21:43:02 +00001603 } else {
1604 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
Douglas Gregor9a28e842010-03-01 23:15:13 +00001605 }
Alexey Bataev4b465392017-04-26 15:06:24 +00001606 if (LangOpts.OpenMP)
1607 pushOpenMPFunctionRegion();
Douglas Gregor9a28e842010-03-01 23:15:13 +00001608}
1609
1610void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
Argyrios Kyrtzidisf51ec1d2010-11-19 00:19:15 +00001611 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
Douglas Gregor9a28e842010-03-01 23:15:13 +00001612 BlockScope, Block));
1613}
1614
Faisal Vali97d8c332013-11-12 01:46:33 +00001615LambdaScopeInfo *Sema::PushLambdaScope() {
Faisal Vali524ca282013-11-12 01:40:44 +00001616 LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1617 FunctionScopes.push_back(LSI);
1618 return LSI;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001619}
1620
1621void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {
1622 if (LambdaScopeInfo *const LSI = getCurLambda()) {
1623 LSI->AutoTemplateParameterDepth = Depth;
1624 return;
Reid Kleckner87a31802018-03-12 21:43:02 +00001625 }
1626 llvm_unreachable(
Faisal Vali2b391ab2013-09-26 19:54:12 +00001627 "Remove assertion if intentionally called in a non-lambda context.");
Eli Friedman71c80552012-01-05 03:35:19 +00001628}
1629
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001630// Check that the type of the VarDecl has an accessible copy constructor and
JF Bastienea51a8c2019-04-30 00:19:43 +00001631// resolve its destructor's exception specification.
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001632static void checkEscapingByref(VarDecl *VD, Sema &S) {
1633 QualType T = VD->getType();
1634 EnterExpressionEvaluationContext scope(
1635 S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1636 SourceLocation Loc = VD->getLocation();
Bruno Ricci5fc4db72018-12-21 14:10:18 +00001637 Expr *VarRef =
1638 new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001639 ExprResult Result = S.PerformMoveOrCopyInitialization(
1640 InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1641 VarRef, /*AllowNRVO=*/true);
1642 if (!Result.isInvalid()) {
1643 Result = S.MaybeCreateExprWithCleanups(Result);
1644 Expr *Init = Result.getAs<Expr>();
1645 S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1646 }
1647
JF Bastienea51a8c2019-04-30 00:19:43 +00001648 // The destructor's exception specification is needed when IRGen generates
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001649 // block copy/destroy functions. Resolve it here.
1650 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1651 if (CXXDestructorDecl *DD = RD->getDestructor()) {
1652 auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1653 S.ResolveExceptionSpec(Loc, FPT);
1654 }
1655}
1656
1657static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1658 // Set the EscapingByref flag of __block variables captured by
1659 // escaping blocks.
1660 for (const BlockDecl *BD : FSI.Blocks) {
1661 if (BD->doesNotEscape())
1662 continue;
1663 for (const BlockDecl::Capture &BC : BD->captures()) {
1664 VarDecl *VD = BC.getVariable();
1665 if (VD->hasAttr<BlocksAttr>())
1666 VD->setEscapingByref();
1667 }
1668 }
1669
1670 for (VarDecl *VD : FSI.ByrefBlockVars) {
1671 // __block variables might require us to capture a copy-initializer.
1672 if (!VD->isEscapingByref())
1673 continue;
1674 // It's currently invalid to ever have a __block variable with an
1675 // array type; should we diagnose that here?
1676 // Regardless, we don't want to ignore array nesting when
1677 // constructing this copy.
1678 if (VD->getType()->isStructureOrClassType())
1679 checkEscapingByref(VD, S);
1680 }
1681}
1682
Richard Smith2fdd95c2019-05-31 00:45:09 +00001683/// Pop a function (or block or lambda or captured region) scope from the stack.
1684///
1685/// \param WP The warning policy to use for CFG-based warnings, or null if such
1686/// warnings should not be produced.
1687/// \param D The declaration corresponding to this function scope, if producing
1688/// CFG-based warnings.
1689/// \param BlockType The type of the block expression, if D is a BlockDecl.
1690Sema::PoppedFunctionScopePtr
1691Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1692 const Decl *D, QualType BlockType) {
Reid Kleckner8d485b82018-03-08 01:12:22 +00001693 assert(!FunctionScopes.empty() && "mismatched push/pop!");
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001694
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001695 markEscapingByrefs(*FunctionScopes.back(), *this);
1696
Richard Smith2fdd95c2019-05-31 00:45:09 +00001697 PoppedFunctionScopePtr Scope(FunctionScopes.pop_back_val(),
1698 PoppedFunctionScopeDeleter(this));
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001699
Alexey Bataev4b465392017-04-26 15:06:24 +00001700 if (LangOpts.OpenMP)
Richard Smith2fdd95c2019-05-31 00:45:09 +00001701 popOpenMPFunctionRegion(Scope.get());
Alexey Bataev4b465392017-04-26 15:06:24 +00001702
Ted Kremenek1767a272011-02-23 01:51:48 +00001703 // Issue any analysis-based warnings.
1704 if (WP && D)
Richard Smith2fdd95c2019-05-31 00:45:09 +00001705 AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
Aaron Ballman130a3b02014-05-15 20:58:55 +00001706 else
1707 for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1708 Diag(PUD.Loc, PUD.PD);
Ted Kremenek1767a272011-02-23 01:51:48 +00001709
Richard Smith2fdd95c2019-05-31 00:45:09 +00001710 return Scope;
1711}
1712
1713void Sema::PoppedFunctionScopeDeleter::
1714operator()(sema::FunctionScopeInfo *Scope) const {
1715 // Stash the function scope for later reuse if it's for a normal function.
1716 if (Scope->isPlainFunction() && !Self->CachedFunctionScope)
1717 Self->CachedFunctionScope.reset(Scope);
1718 else
John McCallaab3e412010-08-25 08:40:02 +00001719 delete Scope;
Douglas Gregor9a28e842010-03-01 23:15:13 +00001720}
1721
Richard Smith6eb9b9e2018-02-03 00:44:57 +00001722void Sema::PushCompoundScope(bool IsStmtExpr) {
1723 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
Dmitri Gribenko800ddf32012-02-14 22:14:32 +00001724}
1725
1726void Sema::PopCompoundScope() {
1727 FunctionScopeInfo *CurFunction = getCurFunction();
1728 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1729
1730 CurFunction->CompoundScopes.pop_back();
1731}
1732
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001733/// Determine whether any errors occurred within this function/method/
Douglas Gregor9a28e842010-03-01 23:15:13 +00001734/// block.
John McCall31168b02011-06-15 23:02:42 +00001735bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1736 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
Douglas Gregor9a28e842010-03-01 23:15:13 +00001737}
1738
Reid Kleckner87a31802018-03-12 21:43:02 +00001739void Sema::setFunctionHasBranchIntoScope() {
1740 if (!FunctionScopes.empty())
1741 FunctionScopes.back()->setHasBranchIntoScope();
1742}
1743
1744void Sema::setFunctionHasBranchProtectedScope() {
1745 if (!FunctionScopes.empty())
1746 FunctionScopes.back()->setHasBranchProtectedScope();
1747}
1748
1749void Sema::setFunctionHasIndirectGoto() {
1750 if (!FunctionScopes.empty())
1751 FunctionScopes.back()->setHasIndirectGoto();
1752}
1753
Douglas Gregor9a28e842010-03-01 23:15:13 +00001754BlockScopeInfo *Sema::getCurBlock() {
1755 if (FunctionScopes.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00001756 return nullptr;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001757
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001758 auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1759 if (CurBSI && CurBSI->TheDecl &&
1760 !CurBSI->TheDecl->Encloses(CurContext)) {
1761 // We have switched contexts due to template instantiation.
Richard Smith696e3122017-02-23 01:43:54 +00001762 assert(!CodeSynthesisContexts.empty());
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001763 return nullptr;
1764 }
1765
1766 return CurBSI;
Douglas Gregor9a28e842010-03-01 23:15:13 +00001767}
John McCall75b960e2010-06-01 09:23:16 +00001768
Reid Kleckner04f9bca2018-03-07 22:48:35 +00001769FunctionScopeInfo *Sema::getEnclosingFunction() const {
1770 if (FunctionScopes.empty())
1771 return nullptr;
1772
1773 for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1774 if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1775 continue;
1776 return FunctionScopes[e];
1777 }
1778 return nullptr;
1779}
1780
Akira Hatanaka7cbbb882017-03-01 06:11:25 +00001781LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
Eli Friedman4817cf72012-01-06 03:05:34 +00001782 if (FunctionScopes.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00001783 return nullptr;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001784
Alexey Bataev31939e32016-11-11 12:36:20 +00001785 auto I = FunctionScopes.rbegin();
Akira Hatanaka7cbbb882017-03-01 06:11:25 +00001786 if (IgnoreNonLambdaCapturingScope) {
Alexey Bataev31939e32016-11-11 12:36:20 +00001787 auto E = FunctionScopes.rend();
Akira Hatanaka7cbbb882017-03-01 06:11:25 +00001788 while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
Alexey Bataev31939e32016-11-11 12:36:20 +00001789 ++I;
1790 if (I == E)
1791 return nullptr;
1792 }
1793 auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001794 if (CurLSI && CurLSI->Lambda &&
1795 !CurLSI->Lambda->Encloses(CurContext)) {
1796 // We have switched contexts due to template instantiation.
Richard Smith696e3122017-02-23 01:43:54 +00001797 assert(!CodeSynthesisContexts.empty());
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001798 return nullptr;
1799 }
1800
1801 return CurLSI;
Eli Friedman4817cf72012-01-06 03:05:34 +00001802}
Fangrui Song6907ce22018-07-30 19:24:48 +00001803// We have a generic lambda if we parsed auto parameters, or we have
Faisal Vali2b391ab2013-09-26 19:54:12 +00001804// an associated template parameter list.
1805LambdaScopeInfo *Sema::getCurGenericLambda() {
1806 if (LambdaScopeInfo *LSI = getCurLambda()) {
Hamza Sood8205a812019-05-04 10:49:46 +00001807 return (LSI->TemplateParams.size() ||
Craig Topperc3ec1492014-05-26 06:22:03 +00001808 LSI->GLTemplateParameterList) ? LSI : nullptr;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001809 }
Craig Topperc3ec1492014-05-26 06:22:03 +00001810 return nullptr;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001811}
1812
Eli Friedman4817cf72012-01-06 03:05:34 +00001813
Dmitri Gribenkoaab83832012-06-20 00:34:58 +00001814void Sema::ActOnComment(SourceRange Comment) {
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00001815 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1816 SourceMgr.isInSystemHeader(Comment.getBegin()))
1817 return;
David L. Jones13d5a872018-03-02 00:07:45 +00001818 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
Dmitri Gribenko052f60d2012-06-22 16:02:55 +00001819 if (RC.isAlmostTrailingComment()) {
1820 SourceRange MagicMarkerRange(Comment.getBegin(),
1821 Comment.getBegin().getLocWithOffset(3));
1822 StringRef MagicMarkerText;
1823 switch (RC.getKind()) {
Abramo Bagnarae06a8882012-07-04 07:30:26 +00001824 case RawComment::RCK_OrdinaryBCPL:
Dmitri Gribenko052f60d2012-06-22 16:02:55 +00001825 MagicMarkerText = "///<";
1826 break;
Abramo Bagnarae06a8882012-07-04 07:30:26 +00001827 case RawComment::RCK_OrdinaryC:
Dmitri Gribenko052f60d2012-06-22 16:02:55 +00001828 MagicMarkerText = "/**<";
1829 break;
1830 default:
1831 llvm_unreachable("if this is an almost Doxygen comment, "
1832 "it should be ordinary");
1833 }
1834 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1835 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1836 }
Dmitri Gribenkoaab83832012-06-20 00:34:58 +00001837 Context.addComment(RC);
1838}
1839
John McCall75b960e2010-06-01 09:23:16 +00001840// Pin this vtable to this file.
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +00001841ExternalSemaSource::~ExternalSemaSource() {}
John McCallfaf5fb42010-08-26 23:41:50 +00001842
Douglas Gregore1716012012-01-25 00:49:42 +00001843void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
Manman Rena0f31a02016-04-29 19:04:05 +00001844void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { }
Sebastian Redlc1ca90a2010-09-28 20:23:00 +00001845
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001846void ExternalSemaSource::ReadKnownNamespaces(
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001847 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001848}
1849
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00001850void ExternalSemaSource::ReadUndefinedButUsed(
Richard Smithd6a04d72016-03-25 21:49:43 +00001851 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
Nick Lewycky8334af82013-01-26 00:35:08 +00001852
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00001853void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<
1854 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1855
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001856/// Figure out if an expression could be turned into a call.
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001857///
1858/// Use this when trying to recover from an error where the programmer may have
1859/// written just the name of a function instead of actually calling it.
1860///
1861/// \param E - The expression to examine.
1862/// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1863/// with no arguments, this parameter is set to the type returned by such a
1864/// call; otherwise, it is set to an empty QualType.
John McCall50a2c2c2011-10-11 23:14:30 +00001865/// \param OverloadSet - If the expression is an overloaded function
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001866/// name, this parameter is populated with the decls of the various overloads.
David Blaikiee5323aa2013-06-21 23:54:45 +00001867bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1868 UnresolvedSetImpl &OverloadSet) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001869 ZeroArgCallReturnTy = QualType();
John McCall50a2c2c2011-10-11 23:14:30 +00001870 OverloadSet.clear();
1871
Craig Topperc3ec1492014-05-26 06:22:03 +00001872 const OverloadExpr *Overloads = nullptr;
David Blaikiee5323aa2013-06-21 23:54:45 +00001873 bool IsMemExpr = false;
John McCall50a2c2c2011-10-11 23:14:30 +00001874 if (E.getType() == Context.OverloadTy) {
1875 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
John McCall50a2c2c2011-10-11 23:14:30 +00001876
David Blaikie6df859d82013-06-04 00:28:46 +00001877 // Ignore overloads that are pointer-to-member constants.
1878 if (FR.HasFormOfMemberPointer)
1879 return false;
1880
1881 Overloads = FR.Expression;
1882 } else if (E.getType() == Context.BoundMemberTy) {
1883 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
David Blaikiee5323aa2013-06-21 23:54:45 +00001884 IsMemExpr = true;
David Blaikie6df859d82013-06-04 00:28:46 +00001885 }
David Blaikiee5323aa2013-06-21 23:54:45 +00001886
1887 bool Ambiguous = false;
Erich Keane3efe0022018-07-20 14:13:28 +00001888 bool IsMV = false;
David Blaikiee5323aa2013-06-21 23:54:45 +00001889
David Blaikie6df859d82013-06-04 00:28:46 +00001890 if (Overloads) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001891 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1892 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
John McCall50a2c2c2011-10-11 23:14:30 +00001893 OverloadSet.addDecl(*it);
1894
David Blaikiee5323aa2013-06-21 23:54:45 +00001895 // Check whether the function is a non-template, non-member which takes no
John McCall50a2c2c2011-10-11 23:14:30 +00001896 // arguments.
David Blaikiee5323aa2013-06-21 23:54:45 +00001897 if (IsMemExpr)
1898 continue;
John McCall50a2c2c2011-10-11 23:14:30 +00001899 if (const FunctionDecl *OverloadDecl
1900 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
David Blaikie6df859d82013-06-04 00:28:46 +00001901 if (OverloadDecl->getMinRequiredArguments() == 0) {
Erich Keane3efe0022018-07-20 14:13:28 +00001902 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1903 (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1904 OverloadDecl->isCPUSpecificMultiVersion()))) {
David Blaikie6df859d82013-06-04 00:28:46 +00001905 ZeroArgCallReturnTy = QualType();
1906 Ambiguous = true;
Erich Keane3efe0022018-07-20 14:13:28 +00001907 } else {
Alp Toker314cc812014-01-25 16:55:45 +00001908 ZeroArgCallReturnTy = OverloadDecl->getReturnType();
Erich Keane3efe0022018-07-20 14:13:28 +00001909 IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1910 OverloadDecl->isCPUSpecificMultiVersion();
1911 }
David Blaikie6df859d82013-06-04 00:28:46 +00001912 }
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001913 }
1914 }
John McCall50a2c2c2011-10-11 23:14:30 +00001915
David Blaikiee5323aa2013-06-21 23:54:45 +00001916 // If it's not a member, use better machinery to try to resolve the call
1917 if (!IsMemExpr)
1918 return !ZeroArgCallReturnTy.isNull();
1919 }
1920
1921 // Attempt to call the member with no arguments - this will correctly handle
1922 // member templates with defaults/deduction of template arguments, overloads
1923 // with default arguments, etc.
Eli Friedman544c9562013-07-08 23:35:04 +00001924 if (IsMemExpr && !E.isTypeDependent()) {
David Blaikiee5323aa2013-06-21 23:54:45 +00001925 bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1926 getDiagnostics().setSuppressAllDiagnostics(true);
Craig Topperc3ec1492014-05-26 06:22:03 +00001927 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(),
1928 None, SourceLocation());
David Blaikiee5323aa2013-06-21 23:54:45 +00001929 getDiagnostics().setSuppressAllDiagnostics(Suppress);
1930 if (R.isUsable()) {
1931 ZeroArgCallReturnTy = R.get()->getType();
1932 return true;
1933 }
1934 return false;
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001935 }
1936
John McCall50a2c2c2011-10-11 23:14:30 +00001937 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001938 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1939 if (Fun->getMinRequiredArguments() == 0)
Alp Toker314cc812014-01-25 16:55:45 +00001940 ZeroArgCallReturnTy = Fun->getReturnType();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001941 return true;
1942 }
1943 }
1944
1945 // We don't have an expression that's convenient to get a FunctionDecl from,
1946 // but we can at least check if the type is "function of 0 arguments".
1947 QualType ExprTy = E.getType();
Craig Topperc3ec1492014-05-26 06:22:03 +00001948 const FunctionType *FunTy = nullptr;
Matt Beaumont-Gay330a5b42011-05-05 00:59:35 +00001949 QualType PointeeTy = ExprTy->getPointeeType();
1950 if (!PointeeTy.isNull())
1951 FunTy = PointeeTy->getAs<FunctionType>();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001952 if (!FunTy)
1953 FunTy = ExprTy->getAs<FunctionType>();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001954
1955 if (const FunctionProtoType *FPT =
1956 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
Alp Toker9cacbab2014-01-20 20:26:09 +00001957 if (FPT->getNumParams() == 0)
Alp Toker314cc812014-01-25 16:55:45 +00001958 ZeroArgCallReturnTy = FunTy->getReturnType();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001959 return true;
1960 }
1961 return false;
1962}
1963
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001964/// Give notes for a set of overloads.
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001965///
David Blaikiee5323aa2013-06-21 23:54:45 +00001966/// A companion to tryExprAsCall. In cases when the name that the programmer
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001967/// wrote was an overloaded function, we may be able to make some guesses about
1968/// plausible overloads based on their return types; such guesses can be handed
1969/// off to this method to be emitted as notes.
1970///
1971/// \param Overloads - The overloads to note.
1972/// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1973/// -fshow-overloads=best, this is the location to attach to the note about too
1974/// many candidates. Typically this will be the location of the original
1975/// ill-formed expression.
John McCall50a2c2c2011-10-11 23:14:30 +00001976static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1977 const SourceLocation FinalNoteLoc) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001978 int ShownOverloads = 0;
1979 int SuppressedOverloads = 0;
1980 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1981 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1982 // FIXME: Magic number for max shown overloads stolen from
1983 // OverloadCandidateSet::NoteCandidates.
Douglas Gregor79591782012-10-23 23:11:23 +00001984 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001985 ++SuppressedOverloads;
1986 continue;
1987 }
John McCall50a2c2c2011-10-11 23:14:30 +00001988
1989 NamedDecl *Fn = (*It)->getUnderlyingDecl();
Erich Keane281d20b2018-01-08 21:34:17 +00001990 // Don't print overloads for non-default multiversioned functions.
1991 if (const auto *FD = Fn->getAsFunction()) {
Erich Keane3efe0022018-07-20 14:13:28 +00001992 if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
Erich Keane281d20b2018-01-08 21:34:17 +00001993 !FD->getAttr<TargetAttr>()->isDefaultVersion())
1994 continue;
1995 }
Abramo Bagnaradc1646d2011-11-15 21:43:28 +00001996 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001997 ++ShownOverloads;
1998 }
John McCall50a2c2c2011-10-11 23:14:30 +00001999
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002000 if (SuppressedOverloads)
John McCall50a2c2c2011-10-11 23:14:30 +00002001 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
2002 << SuppressedOverloads;
2003}
2004
2005static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
2006 const UnresolvedSetImpl &Overloads,
2007 bool (*IsPlausibleResult)(QualType)) {
2008 if (!IsPlausibleResult)
2009 return noteOverloads(S, Overloads, Loc);
2010
2011 UnresolvedSet<2> PlausibleOverloads;
2012 for (OverloadExpr::decls_iterator It = Overloads.begin(),
2013 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2014 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
Alp Toker314cc812014-01-25 16:55:45 +00002015 QualType OverloadResultTy = OverloadDecl->getReturnType();
John McCall50a2c2c2011-10-11 23:14:30 +00002016 if (IsPlausibleResult(OverloadResultTy))
2017 PlausibleOverloads.addDecl(It.getDecl());
2018 }
2019 noteOverloads(S, PlausibleOverloads, Loc);
2020}
2021
2022/// Determine whether the given expression can be called by just
2023/// putting parentheses after it. Notably, expressions with unary
2024/// operators can't be because the unary operator will start parsing
2025/// outside the call.
2026static bool IsCallableWithAppend(Expr *E) {
2027 E = E->IgnoreImplicit();
2028 return (!isa<CStyleCastExpr>(E) &&
2029 !isa<UnaryOperator>(E) &&
2030 !isa<BinaryOperator>(E) &&
2031 !isa<CXXOperatorCallExpr>(E));
2032}
2033
Erich Keane3efe0022018-07-20 14:13:28 +00002034static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {
2035 if (const auto *UO = dyn_cast<UnaryOperator>(E))
2036 E = UO->getSubExpr();
2037
2038 if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2039 if (ULE->getNumDecls() == 0)
2040 return false;
2041
2042 const NamedDecl *ND = *ULE->decls_begin();
2043 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2044 return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
2045 }
2046 return false;
2047}
2048
John McCall50a2c2c2011-10-11 23:14:30 +00002049bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
2050 bool ForceComplain,
2051 bool (*IsPlausibleResult)(QualType)) {
2052 SourceLocation Loc = E.get()->getExprLoc();
2053 SourceRange Range = E.get()->getSourceRange();
2054
2055 QualType ZeroArgCallTy;
2056 UnresolvedSet<4> Overloads;
David Blaikiee5323aa2013-06-21 23:54:45 +00002057 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
John McCall50a2c2c2011-10-11 23:14:30 +00002058 !ZeroArgCallTy.isNull() &&
2059 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
2060 // At this point, we know E is potentially callable with 0
2061 // arguments and that it returns something of a reasonable type,
2062 // so we can emit a fixit and carry on pretending that E was
2063 // actually a CallExpr.
Craig Topper07fa1762015-11-15 02:31:46 +00002064 SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
Erich Keane3efe0022018-07-20 14:13:28 +00002065 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2066 Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
2067 << (IsCallableWithAppend(E.get())
2068 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
2069 : FixItHint());
2070 if (!IsMV)
2071 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
John McCall50a2c2c2011-10-11 23:14:30 +00002072
2073 // FIXME: Try this before emitting the fixit, and suppress diagnostics
2074 // while doing so.
Richard Smith255b85f2019-05-08 01:36:36 +00002075 E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None,
Nick Lewycky1e43d952013-08-21 19:09:44 +00002076 Range.getEnd().getLocWithOffset(1));
John McCall50a2c2c2011-10-11 23:14:30 +00002077 return true;
2078 }
2079
2080 if (!ForceComplain) return false;
2081
Erich Keane3efe0022018-07-20 14:13:28 +00002082 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2083 Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
2084 if (!IsMV)
2085 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
John McCall50a2c2c2011-10-11 23:14:30 +00002086 E = ExprError();
2087 return true;
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002088}
Argyrios Kyrtzidis3e56dd42013-03-14 22:56:43 +00002089
2090IdentifierInfo *Sema::getSuperIdentifier() const {
2091 if (!Ident_super)
2092 Ident_super = &Context.Idents.get("super");
2093 return Ident_super;
2094}
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002095
Nico Webere1687c52013-06-20 21:44:55 +00002096IdentifierInfo *Sema::getFloat128Identifier() const {
2097 if (!Ident___float128)
2098 Ident___float128 = &Context.Idents.get("__float128");
2099 return Ident___float128;
2100}
2101
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002102void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
Ben Langmuire7d7c4c2013-04-29 13:32:41 +00002103 CapturedRegionKind K) {
Nico Weber63816332014-07-26 23:20:08 +00002104 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(
Alexey Bataev7ace49d2016-05-17 08:55:33 +00002105 getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
2106 (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002107 CSI->ReturnType = Context.VoidTy;
2108 FunctionScopes.push_back(CSI);
2109}
2110
2111CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
2112 if (FunctionScopes.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00002113 return nullptr;
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002114
2115 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
2116}
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00002117
2118const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
2119Sema::getMismatchingDeleteExpressions() const {
2120 return DeleteExprs;
2121}
Yaxun Liu5b746652016-12-18 05:18:55 +00002122
2123void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
2124 if (ExtStr.empty())
2125 return;
2126 llvm::SmallVector<StringRef, 1> Exts;
2127 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2128 auto CanT = T.getCanonicalType().getTypePtr();
2129 for (auto &I : Exts)
2130 OpenCLTypeExtMap[CanT].insert(I.str());
2131}
2132
2133void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
2134 llvm::SmallVector<StringRef, 1> Exts;
2135 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2136 if (Exts.empty())
2137 return;
2138 for (auto &I : Exts)
2139 OpenCLDeclExtMap[FD].insert(I.str());
2140}
2141
2142void Sema::setCurrentOpenCLExtensionForType(QualType T) {
2143 if (CurrOpenCLExtension.empty())
2144 return;
2145 setOpenCLExtensionForType(T, CurrOpenCLExtension);
2146}
2147
2148void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) {
2149 if (CurrOpenCLExtension.empty())
2150 return;
2151 setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
2152}
2153
Andrew Savonichev16f16992018-10-11 13:35:34 +00002154std::string Sema::getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD) {
2155 if (!OpenCLDeclExtMap.empty())
2156 return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
2157
2158 return "";
2159}
2160
2161std::string Sema::getOpenCLExtensionsFromTypeExtMap(FunctionType *FT) {
2162 if (!OpenCLTypeExtMap.empty())
2163 return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
2164
2165 return "";
2166}
2167
2168template <typename T, typename MapT>
2169std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
2170 std::string ExtensionNames = "";
2171 auto Loc = Map.find(FDT);
2172
2173 for (auto const& I : Loc->second) {
2174 ExtensionNames += I;
2175 ExtensionNames += " ";
2176 }
2177 ExtensionNames.pop_back();
2178
2179 return ExtensionNames;
2180}
2181
Yaxun Liu5b746652016-12-18 05:18:55 +00002182bool Sema::isOpenCLDisabledDecl(Decl *FD) {
2183 auto Loc = OpenCLDeclExtMap.find(FD);
2184 if (Loc == OpenCLDeclExtMap.end())
2185 return false;
2186 for (auto &I : Loc->second) {
2187 if (!getOpenCLOptions().isEnabled(I))
2188 return true;
2189 }
2190 return false;
2191}
2192
2193template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
2194bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
2195 DiagInfoT DiagInfo, MapT &Map,
2196 unsigned Selector,
2197 SourceRange SrcRange) {
2198 auto Loc = Map.find(D);
2199 if (Loc == Map.end())
2200 return false;
2201 bool Disabled = false;
2202 for (auto &I : Loc->second) {
2203 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
2204 Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
2205 << I << SrcRange;
2206 Disabled = true;
2207 }
2208 }
2209 return Disabled;
2210}
2211
2212bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) {
2213 // Check extensions for declared types.
2214 Decl *Decl = nullptr;
2215 if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
2216 Decl = TypedefT->getDecl();
2217 if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
2218 Decl = TagT->getDecl();
2219 auto Loc = DS.getTypeSpecTypeLoc();
Alexey Sotkin73ae7cb2018-09-03 11:43:22 +00002220
2221 // Check extensions for vector types.
2222 // e.g. double4 is not allowed when cl_khr_fp64 is absent.
2223 if (QT->isExtVectorType()) {
2224 auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
2225 return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
2226 }
2227
Yaxun Liu5b746652016-12-18 05:18:55 +00002228 if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
2229 return true;
2230
2231 // Check extensions for builtin types.
2232 return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2233 QT, OpenCLTypeExtMap);
2234}
2235
Joey Gouly186791d2017-06-30 14:23:01 +00002236bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
2237 IdentifierInfo *FnName = D.getIdentifier();
Stephen Kellyf2ceec42018-08-09 21:08:08 +00002238 return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
Yaxun Liu5b746652016-12-18 05:18:55 +00002239 OpenCLDeclExtMap, 1, D.getSourceRange());
2240}