blob: 077bb0a61acf86ccfe94d5a52e6a7105449eda86 [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;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000161
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000162 LoadedExternalKnownNamespaces = false;
Ted Kremeneke65b0862012-03-06 20:05:56 +0000163 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
Craig Topperc3ec1492014-05-26 06:22:03 +0000164 NSNumberLiteralMethods[I] = nullptr;
Ted Kremeneke65b0862012-03-06 20:05:56 +0000165
Erik Pilkingtonfa983902018-10-30 20:31:30 +0000166 if (getLangOpts().ObjC)
Ted Kremeneke65b0862012-03-06 20:05:56 +0000167 NSAPIObj.reset(new NSAPI(Context));
168
David Blaikiebbafb8a2012-03-11 07:00:24 +0000169 if (getLangOpts().CPlusPlus)
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000170 FieldCollector.reset(new CXXFieldCollector());
Mike Stump11289f42009-09-09 15:08:12 +0000171
Chris Lattner6a2ed6f2008-11-23 09:13:29 +0000172 // Tell diagnostics how to render things from the AST library.
Craig Topper12126262015-11-15 17:27:57 +0000173 Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
Douglas Gregorff790f12009-11-26 00:44:06 +0000174
Faisal Valid143a0c2017-04-01 21:30:49 +0000175 ExprEvalContexts.emplace_back(
176 ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{},
Nicolas Lesserb6d5c582018-07-12 18:45:41 +0000177 nullptr, ExpressionEvaluationContextRecord::EK_Other);
John McCallaab3e412010-08-25 08:40:02 +0000178
Raphael Isemannb23ccec2018-12-10 12:37:46 +0000179 // Initialization of data sharing attributes stack for OpenMP
Alexey Bataev758e55e2013-09-06 18:03:48 +0000180 InitDataSharingAttributesStack();
Alex Lorenz45b40142017-07-28 14:41:21 +0000181
182 std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
183 llvm::make_unique<sema::SemaPPCallbacks>();
184 SemaPPCallbackHandler = Callbacks.get();
185 PP.addPPCallbacks(std::move(Callbacks));
186 SemaPPCallbackHandler->set(*this);
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000187}
188
Alp Tokerf22856a2013-12-18 15:29:05 +0000189void Sema::addImplicitTypedef(StringRef Name, QualType T) {
190 DeclarationName DN = &Context.Idents.get(Name);
191 if (IdResolver.begin(DN) == IdResolver.end())
192 PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);
193}
194
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000195void Sema::Initialize() {
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000196 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
197 SC->InitializeSema(*this);
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000198
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000199 // Tell the external Sema source about this Sema object.
200 if (ExternalSemaSource *ExternalSema
201 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
202 ExternalSema->InitializeSema(*this);
Douglas Gregor3ea72692011-08-12 05:46:01 +0000203
Ben Langmuirbb1c9182014-09-05 20:24:27 +0000204 // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
205 // will not be able to merge any duplicate __va_list_tag decls correctly.
206 VAListTagName = PP.getIdentifierInfo("__va_list_tag");
207
Richard Smith33e0f7e2015-07-22 02:08:40 +0000208 if (!TUScope)
209 return;
210
Douglas Gregor801c99d2011-08-12 06:49:56 +0000211 // Initialize predefined 128-bit integer types, if needed.
Alp Tokerb6cc5922014-05-03 03:45:55 +0000212 if (Context.getTargetInfo().hasInt128Type()) {
Douglas Gregor801c99d2011-08-12 06:49:56 +0000213 // If either of the 128-bit integer types are unavailable to name lookup,
214 // define them now.
215 DeclarationName Int128 = &Context.Idents.get("__int128_t");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000216 if (IdResolver.begin(Int128) == IdResolver.end())
Douglas Gregor801c99d2011-08-12 06:49:56 +0000217 PushOnScopeChains(Context.getInt128Decl(), TUScope);
218
219 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000220 if (IdResolver.begin(UInt128) == IdResolver.end())
Douglas Gregor801c99d2011-08-12 06:49:56 +0000221 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
222 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000223
Douglas Gregor801c99d2011-08-12 06:49:56 +0000224
Douglas Gregor3ea72692011-08-12 05:46:01 +0000225 // Initialize predefined Objective-C types:
Erik Pilkingtonfa983902018-10-30 20:31:30 +0000226 if (getLangOpts().ObjC) {
Douglas Gregor52e02802011-08-12 06:17:30 +0000227 // If 'SEL' does not yet refer to any declarations, make it refer to the
228 // predefined 'SEL'.
229 DeclarationName SEL = &Context.Idents.get("SEL");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000230 if (IdResolver.begin(SEL) == IdResolver.end())
Douglas Gregor52e02802011-08-12 06:17:30 +0000231 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
232
Douglas Gregor3ea72692011-08-12 05:46:01 +0000233 // If 'id' does not yet refer to any declarations, make it refer to the
234 // predefined 'id'.
235 DeclarationName Id = &Context.Idents.get("id");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000236 if (IdResolver.begin(Id) == IdResolver.end())
Douglas Gregor3ea72692011-08-12 05:46:01 +0000237 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000238
Douglas Gregor0a586182011-08-12 05:59:41 +0000239 // Create the built-in typedef for 'Class'.
240 DeclarationName Class = &Context.Idents.get("Class");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000241 if (IdResolver.begin(Class) == IdResolver.end())
Douglas Gregor0a586182011-08-12 05:59:41 +0000242 PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
Douglas Gregord53ae832012-01-17 18:09:05 +0000243
244 // Create the built-in forward declaratino for 'Protocol'.
245 DeclarationName Protocol = &Context.Idents.get("Protocol");
246 if (IdResolver.begin(Protocol) == IdResolver.end())
247 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
Douglas Gregor3ea72692011-08-12 05:46:01 +0000248 }
Meador Inge5d3fb222012-06-16 03:34:49 +0000249
Ben Langmuirf5416742016-02-04 00:55:24 +0000250 // Create the internal type for the *StringMakeConstantString builtins.
251 DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
252 if (IdResolver.begin(ConstantString) == IdResolver.end())
253 PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope);
254
Alp Tokere1fab522014-01-04 15:25:02 +0000255 // Initialize Microsoft "predefined C++ types".
Craig Topper12126262015-11-15 17:27:57 +0000256 if (getLangOpts().MSVCCompat) {
257 if (getLangOpts().CPlusPlus &&
David Majnemerbe525392015-02-18 02:28:13 +0000258 IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
Alp Tokere1fab522014-01-04 15:25:02 +0000259 PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),
260 TUScope);
David Majnemer1de36912014-01-14 06:19:35 +0000261
262 addImplicitTypedef("size_t", Context.getSizeType());
Alp Tokere1fab522014-01-04 15:25:02 +0000263 }
264
Yaxun Liu5b746652016-12-18 05:18:55 +0000265 // Initialize predefined OpenCL types and supported extensions and (optional)
266 // core features.
Craig Topper12126262015-11-15 17:27:57 +0000267 if (getLangOpts().OpenCL) {
Anastasia Stulovae88e2b92019-02-07 17:32:37 +0000268 getOpenCLOptions().addSupport(
269 Context.getTargetInfo().getSupportedOpenCLOpts());
270 getOpenCLOptions().enableSupportedCore(getLangOpts());
Alp Tokerf22856a2013-12-18 15:29:05 +0000271 addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
272 addImplicitTypedef("event_t", Context.OCLEventTy);
Anastasia Stulovae88e2b92019-02-07 17:32:37 +0000273 if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
Alexey Bader9c8453f2015-09-15 11:18:52 +0000274 addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
275 addImplicitTypedef("queue_t", Context.OCLQueueTy);
Alexey Bader9c8453f2015-09-15 11:18:52 +0000276 addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000277 addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));
278 addImplicitTypedef("atomic_uint",
279 Context.getAtomicType(Context.UnsignedIntTy));
Yaxun Liu5b746652016-12-18 05:18:55 +0000280 auto AtomicLongT = Context.getAtomicType(Context.LongTy);
281 addImplicitTypedef("atomic_long", AtomicLongT);
282 auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
283 addImplicitTypedef("atomic_ulong", AtomicULongT);
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000284 addImplicitTypedef("atomic_float",
285 Context.getAtomicType(Context.FloatTy));
Yaxun Liu5b746652016-12-18 05:18:55 +0000286 auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
287 addImplicitTypedef("atomic_double", AtomicDoubleT);
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000288 // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
289 // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
290 addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy));
Yaxun Liu5b746652016-12-18 05:18:55 +0000291 auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());
292 addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);
293 auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());
294 addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);
295 auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());
296 addImplicitTypedef("atomic_size_t", AtomicSizeT);
297 auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType());
298 addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);
299
300 // OpenCL v2.0 s6.13.11.6:
301 // - The atomic_long and atomic_ulong types are supported if the
302 // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
303 // extensions are supported.
304 // - The atomic_double type is only supported if double precision
305 // is supported and the cl_khr_int64_base_atomics and
306 // cl_khr_int64_extended_atomics extensions are supported.
307 // - If the device address space is 64-bits, the data types
308 // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and
309 // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and
310 // cl_khr_int64_extended_atomics extensions are supported.
311 std::vector<QualType> Atomic64BitTypes;
312 Atomic64BitTypes.push_back(AtomicLongT);
313 Atomic64BitTypes.push_back(AtomicULongT);
314 Atomic64BitTypes.push_back(AtomicDoubleT);
315 if (Context.getTypeSize(AtomicSizeT) == 64) {
316 Atomic64BitTypes.push_back(AtomicSizeT);
317 Atomic64BitTypes.push_back(AtomicIntPtrT);
318 Atomic64BitTypes.push_back(AtomicUIntPtrT);
319 Atomic64BitTypes.push_back(AtomicPtrDiffT);
320 }
321 for (auto &I : Atomic64BitTypes)
322 setOpenCLExtensionForType(I,
323 "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
324
325 setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000326 }
Yaxun Liu5b746652016-12-18 05:18:55 +0000327
328 setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");
329
330#define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
331 setOpenCLExtensionForType(Context.Id, Ext);
332#include "clang/Basic/OpenCLImageTypes.def"
Andrew Savonichev3fee3512018-11-08 11:25:41 +0000333#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
334 addImplicitTypedef(#ExtType, Context.Id##Ty); \
335 setOpenCLExtensionForType(Context.Id##Ty, #Ext);
336#include "clang/Basic/OpenCLExtensionTypes.def"
Yaxun Liu5b746652016-12-18 05:18:55 +0000337 };
Alp Tokerf22856a2013-12-18 15:29:05 +0000338
Craig Topper12126262015-11-15 17:27:57 +0000339 if (Context.getTargetInfo().hasBuiltinMSVaList()) {
Charles Davisc7d5c942015-09-17 20:55:33 +0000340 DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
341 if (IdResolver.begin(MSVaList) == IdResolver.end())
342 PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
343 }
344
Meador Inge5d3fb222012-06-16 03:34:49 +0000345 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
346 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
347 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
Steve Naroff38d31b42007-02-28 01:22:02 +0000348}
Chris Lattnercb6a3822006-11-10 06:20:45 +0000349
Anton Korobeynikov55bcea12010-01-10 12:58:08 +0000350Sema::~Sema() {
Eli Friedman570024a2010-08-05 06:57:20 +0000351 if (VisContext) FreeVisContext();
Reid Kleckner87a31802018-03-12 21:43:02 +0000352
John McCallaab3e412010-08-25 08:40:02 +0000353 // Kill all the active scopes.
Reid Kleckner87a31802018-03-12 21:43:02 +0000354 for (sema::FunctionScopeInfo *FSI : FunctionScopes)
Richard Smith2fdd95c2019-05-31 00:45:09 +0000355 delete FSI;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000356
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000357 // Tell the SemaConsumer to forget about us; we're going out of scope.
358 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
359 SC->ForgetSema();
360
361 // Detach from the external Sema source.
362 if (ExternalSemaSource *ExternalSema
Douglas Gregor6fd55e02010-08-13 03:15:25 +0000363 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000364 ExternalSema->ForgetSema();
Axel Naumanndd433f02012-10-18 19:05:02 +0000365
366 // If Sema's ExternalSource is the multiplexer - we own it.
367 if (isMultiplexExternalSource)
368 delete ExternalSource;
Alexey Bataev758e55e2013-09-06 18:03:48 +0000369
DeLesley Hutchinsab1dc2d2015-02-03 22:11:04 +0000370 threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);
371
Alexey Bataev758e55e2013-09-06 18:03:48 +0000372 // Destroys data sharing attributes stack for OpenMP
373 DestroyDataSharingAttributesStack();
Kaelyn Takataef3e42b2014-11-21 18:48:06 +0000374
Alex Lorenz45b40142017-07-28 14:41:21 +0000375 // Detach from the PP callback handler which outlives Sema since it's owned
376 // by the preprocessor.
377 SemaPPCallbackHandler->reset();
378
Kaelyn Takataef3e42b2014-11-21 18:48:06 +0000379 assert(DelayedTypos.empty() && "Uncorrected typos!");
Anton Korobeynikov55bcea12010-01-10 12:58:08 +0000380}
381
John McCall31168b02011-06-15 23:02:42 +0000382/// makeUnavailableInSystemHeader - There is an error in the current
383/// context. If we're still in a system header, and we can plausibly
384/// make the relevant declaration unavailable instead of erroring, do
385/// so and return true.
386bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
John McCallc6af8c62015-10-28 05:03:19 +0000387 UnavailableAttr::ImplicitReason reason) {
John McCall31168b02011-06-15 23:02:42 +0000388 // If we're not in a function, it's an error.
389 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
390 if (!fn) return false;
391
392 // If we're in template instantiation, it's an error.
Richard Smith51ec0cf2017-02-21 01:17:38 +0000393 if (inTemplateInstantiation())
John McCall31168b02011-06-15 23:02:42 +0000394 return false;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000395
John McCall31168b02011-06-15 23:02:42 +0000396 // If that function's not in a system header, it's an error.
397 if (!Context.getSourceManager().isInSystemHeader(loc))
398 return false;
399
400 // If the function is already unavailable, it's not an error.
401 if (fn->hasAttr<UnavailableAttr>()) return true;
402
John McCallc6af8c62015-10-28 05:03:19 +0000403 fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
John McCall31168b02011-06-15 23:02:42 +0000404 return true;
405}
406
Sebastian Redlab238a72011-04-24 16:28:06 +0000407ASTMutationListener *Sema::getASTMutationListener() const {
408 return getASTConsumer().GetASTMutationListener();
409}
410
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000411///Registers an external source. If an external source already exists,
Axel Naumanndd433f02012-10-18 19:05:02 +0000412/// creates a multiplex external source and appends to it.
413///
414///\param[in] E - A non-null external sema source.
415///
416void Sema::addExternalSource(ExternalSemaSource *E) {
417 assert(E && "Cannot use with NULL ptr");
418
419 if (!ExternalSource) {
420 ExternalSource = E;
421 return;
422 }
423
424 if (isMultiplexExternalSource)
425 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
426 else {
427 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
428 isMultiplexExternalSource = true;
429 }
430}
431
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000432/// Print out statistics about the semantic analysis.
Chandler Carruthb4836ea2011-07-06 16:21:37 +0000433void Sema::PrintStats() const {
434 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
435 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
436
437 BumpAlloc.PrintStats();
438 AnalysisWarnings.PrintStats();
439}
440
George Burgess IV8d141e02015-12-14 22:00:49 +0000441void Sema::diagnoseNullableToNonnullConversion(QualType DstType,
442 QualType SrcType,
443 SourceLocation Loc) {
444 Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
445 if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
446 return;
447
448 Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
449 if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
450 return;
451
452 Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
453}
454
Nico Weberd7ba86b2017-05-05 16:11:08 +0000455void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {
Roman Lebedev809df342017-10-26 13:18:14 +0000456 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000457 E->getBeginLoc()))
Roman Lebedev809df342017-10-26 13:18:14 +0000458 return;
459 // nullptr only exists from C++11 on, so don't warn on its absence earlier.
460 if (!getLangOpts().CPlusPlus11)
461 return;
462
Nico Weberd7ba86b2017-05-05 16:11:08 +0000463 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
464 return;
Erich Keane818cf5b2017-10-25 20:23:13 +0000465 if (E->IgnoreParenImpCasts()->getType()->isNullPtrType())
Nico Weberd7ba86b2017-05-05 16:11:08 +0000466 return;
Roman Lebedev809df342017-10-26 13:18:14 +0000467
468 // If it is a macro from system header, and if the macro name is not "NULL",
469 // do not warn.
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000470 SourceLocation MaybeMacroLoc = E->getBeginLoc();
Roman Lebedev809df342017-10-26 13:18:14 +0000471 if (Diags.getSuppressSystemWarnings() &&
472 SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
473 !findMacroSpelling(MaybeMacroLoc, "NULL"))
Nico Weberd7ba86b2017-05-05 16:11:08 +0000474 return;
475
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000476 Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
Nico Weberd7ba86b2017-05-05 16:11:08 +0000477 << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
478}
479
Richard Smith507840d2011-11-29 22:48:16 +0000480/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
481/// If there is already an implicit cast, merge into the existing one.
482/// The result is of the given category.
483ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
484 CastKind Kind, ExprValueKind VK,
485 const CXXCastPath *BasePath,
486 CheckedConversionKind CCK) {
Richard Smith508ebf32011-10-28 03:31:48 +0000487#ifndef NDEBUG
488 if (VK == VK_RValue && !E->isRValue()) {
489 switch (Kind) {
490 default:
Craig Topperd8d43192014-06-18 05:13:13 +0000491 llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
492 "kind");
Richard Smith508ebf32011-10-28 03:31:48 +0000493 case CK_LValueToRValue:
494 case CK_ArrayToPointerDecay:
495 case CK_FunctionToPointerDecay:
496 case CK_ToVoid:
JF Bastien7d60a0f2018-07-18 18:01:41 +0000497 case CK_NonAtomicToAtomic:
Richard Smith508ebf32011-10-28 03:31:48 +0000498 break;
499 }
500 }
Richard Smith4a905b62011-11-10 23:32:36 +0000501 assert((VK == VK_RValue || !E->isRValue()) && "can't cast rvalue to lvalue");
Richard Smith508ebf32011-10-28 03:31:48 +0000502#endif
503
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000504 diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());
Nico Weberd7ba86b2017-05-05 16:11:08 +0000505 diagnoseZeroToNullptrConversion(Kind, E);
Douglas Gregorb4866e82015-06-19 18:13:19 +0000506
John Wiegley01296292011-04-08 18:41:53 +0000507 QualType ExprTy = Context.getCanonicalType(E->getType());
Mon P Wang74b32072008-09-04 08:38:01 +0000508 QualType TypeTy = Context.getCanonicalType(Ty);
Mike Stump11289f42009-09-09 15:08:12 +0000509
Mon P Wang74b32072008-09-04 08:38:01 +0000510 if (ExprTy == TypeTy)
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000511 return E;
Mike Stump11289f42009-09-09 15:08:12 +0000512
Richard Smithb3189a12016-12-05 07:49:14 +0000513 // C++1z [conv.array]: The temporary materialization conversion is applied.
514 // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
515 if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
516 E->getValueKind() == VK_RValue) {
517 // The temporary is an lvalue in C++98 and an xvalue otherwise.
518 ExprResult Materialized = CreateMaterializeTemporaryExpr(
519 E->getType(), E, !getLangOpts().CPlusPlus11);
520 if (Materialized.isInvalid())
521 return ExprError();
522 E = Materialized.get();
523 }
524
Richard Smith507840d2011-11-29 22:48:16 +0000525 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
526 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
527 ImpCast->setType(Ty);
528 ImpCast->setValueKind(VK);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000529 return E;
Richard Smith507840d2011-11-29 22:48:16 +0000530 }
531 }
532
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000533 return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
Sebastian Redlc57d34b2010-07-20 04:20:21 +0000534}
535
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000536/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
537/// to the conversion from scalar type ScalarTy to the Boolean type.
538CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
539 switch (ScalarTy->getScalarTypeKind()) {
540 case Type::STK_Bool: return CK_NoOp;
John McCall9320b872011-09-09 05:25:32 +0000541 case Type::STK_CPointer: return CK_PointerToBoolean;
542 case Type::STK_BlockPointer: return CK_PointerToBoolean;
543 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000544 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
545 case Type::STK_Integral: return CK_IntegralToBoolean;
546 case Type::STK_Floating: return CK_FloatingToBoolean;
547 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
548 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
Leonard Chanb4ba4672018-10-23 17:55:35 +0000549 case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000550 }
Richard Smith354abec2017-12-08 23:29:59 +0000551 llvm_unreachable("unknown scalar type kind");
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000552}
553
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000554/// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000555static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
Rafael Espindola820fa702013-01-08 19:43:34 +0000556 if (D->getMostRecentDecl()->isUsed())
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000557 return true;
558
Rafael Espindola3ae00052013-05-13 00:12:11 +0000559 if (D->isExternallyVisible())
Rafael Espindola0e0d0092013-03-14 03:07:35 +0000560 return true;
561
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000562 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +0000563 // If this is a function template and none of its specializations is used,
564 // we should warn.
565 if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
566 for (const auto *Spec : Template->specializations())
567 if (ShouldRemoveFromUnused(SemaRef, Spec))
568 return true;
569
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000570 // UnusedFileScopedDecls stores the first declaration.
571 // The declaration may have become definition so check again.
572 const FunctionDecl *DeclToCheck;
573 if (FD->hasBody(DeclToCheck))
574 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
575
576 // Later redecls may add new information resulting in not having to warn,
577 // so check again.
Douglas Gregorec9fd132012-01-14 16:38:05 +0000578 DeclToCheck = FD->getMostRecentDecl();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000579 if (DeclToCheck != FD)
580 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
581 }
582
583 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Eli Friedmana5dfebd2013-09-10 21:10:25 +0000584 // If a variable usable in constant expressions is referenced,
585 // don't warn if it isn't used: if the value of a variable is required
586 // for the computation of a constant expression, it doesn't make sense to
587 // warn even if the variable isn't odr-used. (isReferenced doesn't
588 // precisely reflect that, but it's a decent approximation.)
589 if (VD->isReferenced() &&
Richard Smith715f7a12019-06-11 17:50:32 +0000590 VD->mightBeUsableInConstantExpressions(SemaRef->Context))
Eli Friedmana5dfebd2013-09-10 21:10:25 +0000591 return true;
592
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +0000593 if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
594 // If this is a variable template and none of its specializations is used,
595 // we should warn.
596 for (const auto *Spec : Template->specializations())
597 if (ShouldRemoveFromUnused(SemaRef, Spec))
598 return true;
599
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000600 // UnusedFileScopedDecls stores the first declaration.
601 // The declaration may have become definition so check again.
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000602 const VarDecl *DeclToCheck = VD->getDefinition();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000603 if (DeclToCheck)
604 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
605
606 // Later redecls may add new information resulting in not having to warn,
607 // so check again.
Douglas Gregorec9fd132012-01-14 16:38:05 +0000608 DeclToCheck = VD->getMostRecentDecl();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000609 if (DeclToCheck != VD)
610 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
611 }
612
613 return false;
614}
615
Richard Smith405e2db2017-09-20 07:22:00 +0000616static bool isFunctionOrVarDeclExternC(NamedDecl *ND) {
617 if (auto *FD = dyn_cast<FunctionDecl>(ND))
618 return FD->isExternC();
619 return cast<VarDecl>(ND)->isExternC();
620}
621
622/// Determine whether ND is an external-linkage function or variable whose
623/// type has no linkage.
624bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) {
625 // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
626 // because we also want to catch the case where its type has VisibleNoLinkage,
627 // which does not affect the linkage of VD.
628 return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
629 !isExternalFormalLinkage(VD->getType()->getLinkage()) &&
630 !isFunctionOrVarDeclExternC(VD);
631}
632
Richard Smith62f19e72016-06-25 00:15:56 +0000633/// Obtains a sorted list of functions and variables that are undefined but
634/// ODR-used.
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000635void Sema::getUndefinedButUsed(
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000636 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
Richard Smithd6a04d72016-03-25 21:49:43 +0000637 for (const auto &UndefinedUse : UndefinedButUsed) {
638 NamedDecl *ND = UndefinedUse.first;
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000639
640 // Ignore attributes that have become invalid.
641 if (ND->isInvalidDecl()) continue;
642
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000643 // __attribute__((weakref)) is basically a definition.
644 if (ND->hasAttr<WeakRefAttr>()) continue;
645
Richard Smith57865822017-08-03 19:24:27 +0000646 if (isa<CXXDeductionGuideDecl>(ND))
647 continue;
648
Richard Smith405e2db2017-09-20 07:22:00 +0000649 if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
650 // An exported function will always be emitted when defined, so even if
651 // the function is inline, it doesn't have to be emitted in this TU. An
652 // imported function implies that it has been exported somewhere else.
653 continue;
654 }
655
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000656 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
657 if (FD->isDefined())
658 continue;
Rafael Espindola3ae00052013-05-13 00:12:11 +0000659 if (FD->isExternallyVisible() &&
Richard Smith405e2db2017-09-20 07:22:00 +0000660 !isExternalWithNoLinkageType(FD) &&
Louis Dionned2695792018-10-04 15:49:42 +0000661 !FD->getMostRecentDecl()->isInlined() &&
662 !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000663 continue;
Reid Klecknerc8ae8782018-06-20 21:12:20 +0000664 if (FD->getBuiltinID())
665 continue;
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000666 } else {
Richard Smith62f19e72016-06-25 00:15:56 +0000667 auto *VD = cast<VarDecl>(ND);
668 if (VD->hasDefinition() != VarDecl::DeclarationOnly)
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000669 continue;
Richard Smith405e2db2017-09-20 07:22:00 +0000670 if (VD->isExternallyVisible() &&
671 !isExternalWithNoLinkageType(VD) &&
Louis Dionned2695792018-10-04 15:49:42 +0000672 !VD->getMostRecentDecl()->isInline() &&
673 !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000674 continue;
Justin Lebar5489f852018-05-17 16:15:07 +0000675
676 // Skip VarDecls that lack formal definitions but which we know are in
677 // fact defined somewhere.
678 if (VD->isKnownToBeDefined())
679 continue;
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000680 }
681
Richard Smithd6a04d72016-03-25 21:49:43 +0000682 Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000683 }
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000684}
685
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000686/// checkUndefinedButUsed - Check for undefined objects with internal linkage
687/// or that are inline.
688static void checkUndefinedButUsed(Sema &S) {
689 if (S.UndefinedButUsed.empty()) return;
John McCall83779672011-02-19 02:53:41 +0000690
691 // Collect all the still-undefined entities with internal linkage.
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000692 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000693 S.getUndefinedButUsed(Undefined);
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000694 if (Undefined.empty()) return;
John McCall83779672011-02-19 02:53:41 +0000695
Richard Smith405e2db2017-09-20 07:22:00 +0000696 for (auto Undef : Undefined) {
697 ValueDecl *VD = cast<ValueDecl>(Undef.first);
698 SourceLocation UseLoc = Undef.second;
John McCall83779672011-02-19 02:53:41 +0000699
Richard Smith405e2db2017-09-20 07:22:00 +0000700 if (S.isExternalWithNoLinkageType(VD)) {
701 // C++ [basic.link]p8:
702 // A type without linkage shall not be used as the type of a variable
703 // or function with external linkage unless
704 // -- the entity has C language linkage
705 // -- the entity is not odr-used or is defined in the same TU
706 //
707 // As an extension, accept this in cases where the type is externally
708 // visible, since the function or variable actually can be defined in
709 // another translation unit in that case.
710 S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage())
711 ? diag::ext_undefined_internal_type
712 : diag::err_undefined_internal_type)
713 << isa<VarDecl>(VD) << VD;
714 } else if (!VD->isExternallyVisible()) {
715 // FIXME: We can promote this to an error. The function or variable can't
716 // be defined anywhere else, so the program must necessarily violate the
717 // one definition rule.
718 S.Diag(VD->getLocation(), diag::warn_undefined_internal)
719 << isa<VarDecl>(VD) << VD;
720 } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
James Y Knight5b218ff2016-06-25 16:40:53 +0000721 (void)FD;
Richard Smith62f19e72016-06-25 00:15:56 +0000722 assert(FD->getMostRecentDecl()->isInlined() &&
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000723 "used object requires definition but isn't inline or internal?");
Richard Smith62f19e72016-06-25 00:15:56 +0000724 // FIXME: This is ill-formed; we should reject.
Richard Smith405e2db2017-09-20 07:22:00 +0000725 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
Richard Smith62f19e72016-06-25 00:15:56 +0000726 } else {
Richard Smith405e2db2017-09-20 07:22:00 +0000727 assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
Richard Smith62f19e72016-06-25 00:15:56 +0000728 "used var requires definition but isn't inline or internal?");
Richard Smith405e2db2017-09-20 07:22:00 +0000729 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000730 }
Richard Smith405e2db2017-09-20 07:22:00 +0000731 if (UseLoc.isValid())
732 S.Diag(UseLoc, diag::note_used_here);
John McCall83779672011-02-19 02:53:41 +0000733 }
Richard Smithd6a04d72016-03-25 21:49:43 +0000734
735 S.UndefinedButUsed.clear();
John McCall83779672011-02-19 02:53:41 +0000736}
737
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000738void Sema::LoadExternalWeakUndeclaredIdentifiers() {
739 if (!ExternalSource)
740 return;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000741
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000742 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
743 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
Chandler Carruthf85d9822015-03-26 08:32:49 +0000744 for (auto &WeakID : WeakIDs)
745 WeakUndeclaredIdentifiers.insert(WeakID);
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000746}
747
Daniel Jasper0baec5492012-06-06 08:32:04 +0000748
749typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
750
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000751/// Returns true, if all methods and nested classes of the given
Daniel Jasper0baec5492012-06-06 08:32:04 +0000752/// CXXRecordDecl are defined in this translation unit.
753///
754/// Should only be called from ActOnEndOfTranslationUnit so that all
755/// definitions are actually read.
756static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
757 RecordCompleteMap &MNCComplete) {
758 RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
759 if (Cache != MNCComplete.end())
760 return Cache->second;
761 if (!RD->isCompleteDefinition())
762 return false;
763 bool Complete = true;
764 for (DeclContext::decl_iterator I = RD->decls_begin(),
765 E = RD->decls_end();
766 I != E && Complete; ++I) {
767 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
Richard Smitha31174e2017-11-01 04:52:12 +0000768 Complete = M->isDefined() || M->isDefaulted() ||
769 (M->isPure() && !isa<CXXDestructorDecl>(M));
Daniel Jaspere99c2bf2012-06-14 20:56:06 +0000770 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
Nico Weber4bde6c22015-06-18 20:09:49 +0000771 // If the template function is marked as late template parsed at this
772 // point, it has not been instantiated and therefore we have not
773 // performed semantic analysis on it yet, so we cannot know if the type
774 // can be considered complete.
Ehsan Akhgari4b5ca9a2014-10-11 00:24:15 +0000775 Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
776 F->getTemplatedDecl()->isDefined();
Daniel Jasper0baec5492012-06-06 08:32:04 +0000777 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
778 if (R->isInjectedClassName())
779 continue;
780 if (R->hasDefinition())
781 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
782 MNCComplete);
783 else
784 Complete = false;
785 }
786 }
787 MNCComplete[RD] = Complete;
788 return Complete;
789}
790
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000791/// Returns true, if the given CXXRecordDecl is fully defined in this
Daniel Jasper0baec5492012-06-06 08:32:04 +0000792/// translation unit, i.e. all methods are defined or pure virtual and all
793/// friends, friend functions and nested classes are fully defined in this
794/// translation unit.
795///
796/// Should only be called from ActOnEndOfTranslationUnit so that all
797/// definitions are actually read.
798static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
799 RecordCompleteMap &RecordsComplete,
800 RecordCompleteMap &MNCComplete) {
801 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
802 if (Cache != RecordsComplete.end())
803 return Cache->second;
804 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
805 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
806 E = RD->friend_end();
807 I != E && Complete; ++I) {
808 // Check if friend classes and methods are complete.
809 if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
810 // Friend classes are available as the TypeSourceInfo of the FriendDecl.
811 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
812 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
813 else
814 Complete = false;
815 } else {
816 // Friend functions are available through the NamedDecl of FriendDecl.
817 if (const FunctionDecl *FD =
818 dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
819 Complete = FD->isDefined();
820 else
821 // This is a template friend, give up.
822 Complete = false;
823 }
824 }
825 RecordsComplete[RD] = Complete;
826 return Complete;
827}
828
Nico Weber72889432014-09-06 01:25:55 +0000829void Sema::emitAndClearUnusedLocalTypedefWarnings() {
830 if (ExternalSource)
831 ExternalSource->ReadUnusedLocalTypedefNameCandidates(
832 UnusedLocalTypedefNameCandidates);
833 for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {
834 if (TD->isReferenced())
835 continue;
836 Diag(TD->getLocation(), diag::warn_unused_local_typedef)
837 << isa<TypeAliasDecl>(TD) << TD->getDeclName();
838 }
839 UnusedLocalTypedefNameCandidates.clear();
840}
841
Richard Smithe03a6542017-07-05 01:42:07 +0000842/// This is called before the very first declaration in the translation unit
843/// is parsed. Note that the ASTContext may have already injected some
844/// declarations.
845void Sema::ActOnStartOfTranslationUnit() {
Richard Smithac9f7fb2018-09-15 01:59:39 +0000846 if (getLangOpts().ModulesTS &&
847 (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
848 getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
Richard Smithd652bdd2019-04-14 08:06:59 +0000849 // We start in an implied global module fragment.
Richard Smithdd8b5332017-09-04 05:37:53 +0000850 SourceLocation StartOfTU =
851 SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
Richard Smithd652bdd2019-04-14 08:06:59 +0000852 ActOnGlobalModuleFragmentDecl(StartOfTU);
853 ModuleScopes.back().ImplicitGlobalModuleFragment = true;
Richard Smithe03a6542017-07-05 01:42:07 +0000854 }
855}
856
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000857void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) {
858 // No explicit actions are required at the end of the global module fragment.
859 if (Kind == TUFragmentKind::Global)
Douglas Gregorc459b512012-08-17 22:17:36 +0000860 return;
861
Reid Kleckner24bd88c2018-03-26 18:22:47 +0000862 // Transfer late parsed template instantiations over to the pending template
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000863 // instantiation list. During normal compilation, the late template parser
Reid Kleckner24bd88c2018-03-26 18:22:47 +0000864 // will be installed and instantiating these templates will succeed.
865 //
866 // If we are building a TU prefix for serialization, it is also safe to
867 // transfer these over, even though they are not parsed. The end of the TU
868 // should be outside of any eager template instantiation scope, so when this
869 // AST is deserialized, these templates will not be parsed until the end of
870 // the combined TU.
871 PendingInstantiations.insert(PendingInstantiations.end(),
872 LateParsedInstantiations.begin(),
873 LateParsedInstantiations.end());
874 LateParsedInstantiations.clear();
875
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000876 // If DefinedUsedVTables ends up marking any virtual member functions it
877 // might lead to more pending template instantiations, which we then need
878 // to instantiate.
879 DefineUsedVTables();
880
881 // C++: Perform implicit template instantiations.
882 //
883 // FIXME: When we perform these implicit instantiations, we do not
884 // carefully keep track of the point of instantiation (C++ [temp.point]).
885 // This means that name lookup that occurs within the template
886 // instantiation will always happen at the end of the translation unit,
887 // so it will find some names that are not required to be found. This is
888 // valid, but we could do better by diagnosing if an instantiation uses a
889 // name that was not visible at its first point of instantiation.
890 if (ExternalSource) {
891 // Load pending instantiations from the external source.
892 SmallVector<PendingImplicitInstantiation, 4> Pending;
893 ExternalSource->ReadPendingInstantiations(Pending);
894 for (auto PII : Pending)
895 if (auto Func = dyn_cast<FunctionDecl>(PII.first))
896 Func->setInstantiationIsPending(true);
897 PendingInstantiations.insert(PendingInstantiations.begin(),
898 Pending.begin(), Pending.end());
899 }
900
901 {
902 llvm::TimeTraceScope TimeScope("PerformPendingInstantiations",
903 StringRef(""));
904 PerformPendingInstantiations();
905 }
906
907 assert(LateParsedInstantiations.empty() &&
908 "end of TU template instantiation should not create more "
909 "late-parsed templates");
910}
911
912/// ActOnEndOfTranslationUnit - This is called at the very end of the
913/// translation unit when EOF is reached and all but the top-level scope is
914/// popped.
915void Sema::ActOnEndOfTranslationUnit() {
916 assert(DelayedDiagnostics.getCurrentPool() == nullptr
917 && "reached end of translation unit with a pool attached?");
918
919 // If code completion is enabled, don't perform any end-of-translation-unit
920 // work.
921 if (PP.isCodeCompletionEnabled())
922 return;
923
Richard Smith0e5d7b82013-07-25 23:08:39 +0000924 // Complete translation units and modules define vtables and perform implicit
925 // instantiations. PCH files do not.
926 if (TUKind != TU_Prefix) {
Argyrios Kyrtzidisb6c6a582012-02-07 16:50:53 +0000927 DiagnoseUseOfUnimplementedSelectors();
928
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000929 ActOnEndOfTranslationUnitFragment(
930 !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
931 Module::PrivateModuleFragment
932 ? TUFragmentKind::Private
933 : TUFragmentKind::Normal);
Reid Kleckner24bd88c2018-03-26 18:22:47 +0000934
Reid Kleckner89bd8d62014-10-22 17:50:19 +0000935 if (LateTemplateParserCleanup)
936 LateTemplateParserCleanup(OpaqueParser);
937
Alp Tokerae3a9442013-10-18 05:54:19 +0000938 CheckDelayedMemberExceptionSpecs();
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000939 } else {
940 // If we are building a TU prefix for serialization, it is safe to transfer
941 // these over, even though they are not parsed. The end of the TU should be
942 // outside of any eager template instantiation scope, so when this AST is
943 // deserialized, these templates will not be parsed until the end of the
944 // combined TU.
945 PendingInstantiations.insert(PendingInstantiations.end(),
946 LateParsedInstantiations.begin(),
947 LateParsedInstantiations.end());
948 LateParsedInstantiations.clear();
Nick Lewyckyef4f4562010-11-25 00:35:20 +0000949 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000950
Alex Lorenz45b40142017-07-28 14:41:21 +0000951 DiagnoseUnterminatedPragmaPack();
Alex Lorenz9e7bf162017-04-18 14:33:39 +0000952 DiagnoseUnterminatedPragmaAttribute();
953
Alp Tokerae3a9442013-10-18 05:54:19 +0000954 // All delayed member exception specs should be checked or we end up accepting
955 // incompatible declarations.
Richard Smith5159bbad2018-09-05 22:30:37 +0000956 assert(DelayedOverridingExceptionSpecChecks.empty());
957 assert(DelayedEquivalentExceptionSpecChecks.empty());
Alp Tokerae3a9442013-10-18 05:54:19 +0000958
Hans Wennborg99000c22015-08-15 01:18:16 +0000959 // All dllexport classes should have been processed already.
960 assert(DelayedDllExportClasses.empty());
961
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +0000962 // Remove file scoped decls that turned out to be used.
Daniel Jasper9ba6f9b2013-04-30 06:43:16 +0000963 UnusedFileScopedDecls.erase(
Craig Topperc3ec1492014-05-26 06:22:03 +0000964 std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
Daniel Jasper9ba6f9b2013-04-30 06:43:16 +0000965 UnusedFileScopedDecls.end(),
Richard Smith2c27df72017-03-23 23:17:58 +0000966 [this](const DeclaratorDecl *DD) {
967 return ShouldRemoveFromUnused(this, DD);
968 }),
Daniel Jasper9ba6f9b2013-04-30 06:43:16 +0000969 UnusedFileScopedDecls.end());
Douglas Gregorfb8b27d2010-04-09 17:41:13 +0000970
Douglas Gregor69f74f82011-08-25 22:30:56 +0000971 if (TUKind == TU_Prefix) {
972 // Translation unit prefixes don't need any of the checking below.
Vassil Vassilev45bf62f2016-10-17 10:15:25 +0000973 if (!PP.isIncrementalProcessingEnabled())
974 TUScope = nullptr;
Argyrios Kyrtzidisee1afa32010-08-05 09:48:08 +0000975 return;
Douglas Gregorb14904c2010-08-13 22:48:40 +0000976 }
Argyrios Kyrtzidisee1afa32010-08-05 09:48:08 +0000977
Chris Lattner0c797362009-09-08 18:19:27 +0000978 // Check for #pragma weak identifiers that were never declared
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000979 LoadExternalWeakUndeclaredIdentifiers();
Chandler Carruthf85d9822015-03-26 08:32:49 +0000980 for (auto WeakID : WeakUndeclaredIdentifiers) {
981 if (WeakID.second.getUsed())
982 continue;
Mike Stump11289f42009-09-09 15:08:12 +0000983
Alexander Musmanfbbc0b82015-09-18 07:40:22 +0000984 Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
985 LookupOrdinaryName);
986 if (PrevDecl != nullptr &&
987 !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
988 Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
989 << "'weak'" << ExpectedVariableOrFunction;
990 else
991 Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
992 << WeakID.first;
Ryan Flynn7d470f32009-07-30 03:15:39 +0000993 }
994
Argyrios Kyrtzidisffb35582013-03-14 04:44:56 +0000995 if (LangOpts.CPlusPlus11 &&
Alp Tokerd4a3f0e2014-06-15 23:30:39 +0000996 !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
Argyrios Kyrtzidisffb35582013-03-14 04:44:56 +0000997 CheckDelegatingCtorCycles();
998
Richard Smithd6a04d72016-03-25 21:49:43 +0000999 if (!Diags.hasErrorOccurred()) {
1000 if (ExternalSource)
1001 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
1002 checkUndefinedButUsed(*this);
1003 }
1004
Richard Smithd652bdd2019-04-14 08:06:59 +00001005 // A global-module-fragment is only permitted within a module unit.
1006 bool DiagnosedMissingModuleDeclaration = false;
1007 if (!ModuleScopes.empty() &&
1008 ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment &&
1009 !ModuleScopes.back().ImplicitGlobalModuleFragment) {
1010 Diag(ModuleScopes.back().BeginLoc,
1011 diag::err_module_declaration_missing_after_global_module_introducer);
1012 DiagnosedMissingModuleDeclaration = true;
1013 }
1014
Douglas Gregor69f74f82011-08-25 22:30:56 +00001015 if (TUKind == TU_Module) {
Richard Smith18057cb2017-10-11 00:36:56 +00001016 // If we are building a module interface unit, we need to have seen the
1017 // module declaration by now.
1018 if (getLangOpts().getCompilingModule() ==
1019 LangOptions::CMK_ModuleInterface &&
Richard Smithd6509cf2018-09-15 01:21:15 +00001020 (ModuleScopes.empty() ||
Richard Smitha5bbbfe2019-04-18 21:12:54 +00001021 !ModuleScopes.back().Module->isModulePurview()) &&
Richard Smithd652bdd2019-04-14 08:06:59 +00001022 !DiagnosedMissingModuleDeclaration) {
Richard Smith18057cb2017-10-11 00:36:56 +00001023 // FIXME: Make a better guess as to where to put the module declaration.
1024 Diag(getSourceManager().getLocForStartOfFile(
1025 getSourceManager().getMainFileID()),
1026 diag::err_module_declaration_missing);
1027 }
1028
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001029 // If we are building a module, resolve all of the exported declarations
1030 // now.
1031 if (Module *CurrentModule = PP.getCurrentModule()) {
1032 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001033
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001034 SmallVector<Module *, 2> Stack;
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001035 Stack.push_back(CurrentModule);
1036 while (!Stack.empty()) {
Robert Wilhelm25284cc2013-08-23 16:11:15 +00001037 Module *Mod = Stack.pop_back_val();
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001038
Douglas Gregorfb912652013-03-20 21:10:35 +00001039 // Resolve the exported declarations and conflicts.
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001040 // FIXME: Actually complain, once we figure out how to teach the
Douglas Gregorfb912652013-03-20 21:10:35 +00001041 // diagnostic client to deal with complaints in the module map at this
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001042 // point.
1043 ModMap.resolveExports(Mod, /*Complain=*/false);
Daniel Jasperba7f2f72013-09-24 09:14:14 +00001044 ModMap.resolveUses(Mod, /*Complain=*/false);
Douglas Gregorfb912652013-03-20 21:10:35 +00001045 ModMap.resolveConflicts(Mod, /*Complain=*/false);
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001046
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001047 // Queue the submodules, so their exports will also be resolved.
Benjamin Kramerf367dd92015-06-12 15:31:50 +00001048 Stack.append(Mod->submodule_begin(), Mod->submodule_end());
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001049 }
1050 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001051
Nico Weber72889432014-09-06 01:25:55 +00001052 // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1053 // modules when they are built, not every time they are used.
1054 emitAndClearUnusedLocalTypedefWarnings();
Douglas Gregor69f74f82011-08-25 22:30:56 +00001055 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001056
Douglas Gregor0760fa12009-03-10 23:43:53 +00001057 // C99 6.9.2p2:
1058 // A declaration of an identifier for an object that has file
1059 // scope without an initializer, and without a storage-class
1060 // specifier or with the storage-class specifier static,
1061 // constitutes a tentative definition. If a translation unit
1062 // contains one or more tentative definitions for an identifier,
1063 // and the translation unit contains no external definition for
1064 // that identifier, then the behavior is exactly as if the
1065 // translation unit contains a file scope declaration of that
1066 // identifier, with the composite type as of the end of the
1067 // translation unit, with an initializer equal to 0.
Sebastian Redl35351a92010-01-31 22:27:38 +00001068 llvm::SmallSet<VarDecl *, 32> Seen;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001069 for (TentativeDefinitionsType::iterator
Douglas Gregoreb08bd42011-07-27 20:58:46 +00001070 T = TentativeDefinitions.begin(ExternalSource),
1071 TEnd = TentativeDefinitions.end();
Richard Smithf5262c62018-06-28 01:57:04 +00001072 T != TEnd; ++T) {
Douglas Gregoreb08bd42011-07-27 20:58:46 +00001073 VarDecl *VD = (*T)->getActingDefinition();
Mike Stump11289f42009-09-09 15:08:12 +00001074
Sebastian Redl35351a92010-01-31 22:27:38 +00001075 // If the tentative definition was completed, getActingDefinition() returns
1076 // null. If we've already seen this variable before, insert()'s second
1077 // return value is false.
David Blaikie82e95a32014-11-19 07:49:47 +00001078 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
Douglas Gregorbeecd582009-04-21 17:11:58 +00001079 continue;
1080
Mike Stump11289f42009-09-09 15:08:12 +00001081 if (const IncompleteArrayType *ArrayT
Douglas Gregorbeecd582009-04-21 17:11:58 +00001082 = Context.getAsIncompleteArrayType(VD->getType())) {
Chris Lattner0c797362009-09-08 18:19:27 +00001083 // Set the length of the array to 1 (C99 6.9.2p5).
1084 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1085 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
John McCallc5b82252009-10-16 00:14:28 +00001086 QualType T = Context.getConstantArrayType(ArrayT->getElementType(),
1087 One, ArrayType::Normal, 0);
Chris Lattner0c797362009-09-08 18:19:27 +00001088 VD->setType(T);
Mike Stump11289f42009-09-09 15:08:12 +00001089 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
Douglas Gregorbeecd582009-04-21 17:11:58 +00001090 diag::err_tentative_def_incomplete_type))
1091 VD->setInvalidDecl();
1092
Richard Smith7873de02016-08-11 22:25:46 +00001093 // No initialization is performed for a tentative definition.
Richard Smith3997b1b2016-08-12 01:55:21 +00001094 CheckCompleteVariableDeclaration(VD);
Eli Friedman7d14b3c2012-10-23 20:19:32 +00001095
Douglas Gregorbeecd582009-04-21 17:11:58 +00001096 // Notify the consumer that we've completed a tentative definition.
1097 if (!VD->isInvalidDecl())
1098 Consumer.CompleteTentativeDefinition(VD);
Douglas Gregor0760fa12009-03-10 23:43:53 +00001099 }
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001100
1101 // If there were errors, disable 'unused' warnings since they will mostly be
Richard Smithf5262c62018-06-28 01:57:04 +00001102 // noise. Don't warn for a use from a module: either we should warn on all
1103 // file-scope declarations in modules or not at all, but whether the
1104 // declaration is used is immaterial.
1105 if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001106 // Output warning for unused file scoped decls.
Douglas Gregora94a1542011-07-27 21:45:57 +00001107 for (UnusedFileScopedDeclsType::iterator
1108 I = UnusedFileScopedDecls.begin(ExternalSource),
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001109 E = UnusedFileScopedDecls.end(); I != E; ++I) {
Douglas Gregora94a1542011-07-27 21:45:57 +00001110 if (ShouldRemoveFromUnused(this, *I))
1111 continue;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001112
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001113 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1114 const FunctionDecl *DiagD;
1115 if (!FD->hasBody(DiagD))
1116 DiagD = FD;
Argyrios Kyrtzidise0283142011-03-03 17:47:42 +00001117 if (DiagD->isDeleted())
1118 continue; // Deleted functions are supposed to be unused.
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001119 if (DiagD->isReferenced()) {
1120 if (isa<CXXMethodDecl>(DiagD))
1121 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1122 << DiagD->getDeclName();
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001123 else {
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001124 if (FD->getStorageClass() == SC_Static &&
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001125 !FD->isInlineSpecified() &&
Eli Friedman5ba37d52013-08-22 00:27:10 +00001126 !SourceMgr.isInMainFile(
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001127 SourceMgr.getExpansionLoc(FD->getLocation())))
Nico Weber63816332014-07-26 23:20:08 +00001128 Diag(DiagD->getLocation(),
1129 diag::warn_unneeded_static_internal_decl)
1130 << DiagD->getDeclName();
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001131 else
1132 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1133 << /*function*/0 << DiagD->getDeclName();
1134 }
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001135 } else {
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +00001136 if (FD->getDescribedFunctionTemplate())
1137 Diag(DiagD->getLocation(), diag::warn_unused_template)
1138 << /*function*/0 << DiagD->getDeclName();
1139 else
1140 Diag(DiagD->getLocation(),
1141 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1142 : diag::warn_unused_function)
1143 << DiagD->getDeclName();
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001144 }
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001145 } else {
1146 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1147 if (!DiagD)
1148 DiagD = cast<VarDecl>(*I);
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001149 if (DiagD->isReferenced()) {
1150 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1151 << /*variable*/1 << DiagD->getDeclName();
Daniel Jasperc531dae2013-09-11 10:37:35 +00001152 } else if (DiagD->getType().isConstQualified()) {
Erik Verbruggen89aa7eb2016-10-28 08:28:42 +00001153 const SourceManager &SM = SourceMgr;
1154 if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1155 !PP.getLangOpts().IsHeaderFile)
1156 Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1157 << DiagD->getDeclName();
Eli Friedman5ef21752013-09-10 03:05:56 +00001158 } else {
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +00001159 if (DiagD->getDescribedVarTemplate())
1160 Diag(DiagD->getLocation(), diag::warn_unused_template)
1161 << /*variable*/1 << DiagD->getDeclName();
1162 else
1163 Diag(DiagD->getLocation(), diag::warn_unused_variable)
Matt Beaumont-Gaye1368a12013-04-10 00:47:10 +00001164 << DiagD->getDeclName();
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001165 }
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001166 }
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001167 }
John McCall83779672011-02-19 02:53:41 +00001168
Nico Weber72889432014-09-06 01:25:55 +00001169 emitAndClearUnusedLocalTypedefWarnings();
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +00001170 }
Douglas Gregorb14904c2010-08-13 22:48:40 +00001171
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00001172 if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
Richard Smithf5262c62018-06-28 01:57:04 +00001173 // FIXME: Load additional unused private field candidates from the external
1174 // source.
Daniel Jasper0baec5492012-06-06 08:32:04 +00001175 RecordCompleteMap RecordsComplete;
1176 RecordCompleteMap MNCComplete;
1177 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1178 E = UnusedPrivateFields.end(); I != E; ++I) {
1179 const NamedDecl *D = *I;
1180 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1181 if (RD && !RD->isUnion() &&
1182 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1183 Diag(D->getLocation(), diag::warn_unused_private_field)
1184 << D->getDeclName();
1185 }
1186 }
1187 }
1188
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00001189 if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1190 if (ExternalSource)
1191 ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs);
1192 for (const auto &DeletedFieldInfo : DeleteExprs) {
1193 for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1194 AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1195 DeleteExprLoc.second);
1196 }
1197 }
1198 }
1199
Richard Smithb2bc2e62011-02-21 20:05:19 +00001200 // Check we've noticed that we're no longer parsing the initializer for every
1201 // variable. If we miss cases, then at best we have a performance issue and
1202 // at worst a rejects-valid bug.
1203 assert(ParsingInitForAutoVars.empty() &&
1204 "Didn't unmark var as having its initializer parsed");
1205
Vassil Vassilev45bf62f2016-10-17 10:15:25 +00001206 if (!PP.isIncrementalProcessingEnabled())
1207 TUScope = nullptr;
Chris Lattnerf4404402008-08-23 03:19:52 +00001208}
1209
1210
Chris Lattnerc11438c2006-08-18 05:17:52 +00001211//===----------------------------------------------------------------------===//
Chris Lattnereaafe1222006-11-10 05:17:58 +00001212// Helper functions.
1213//===----------------------------------------------------------------------===//
1214
Anders Carlssonb26ab812009-08-08 17:45:02 +00001215DeclContext *Sema::getFunctionLevelDeclContext() {
John McCallb8788012009-12-19 10:53:49 +00001216 DeclContext *DC = CurContext;
Mike Stump11289f42009-09-09 15:08:12 +00001217
Eli Friedman73a04092012-01-07 04:59:52 +00001218 while (true) {
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00001219 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
Eli Friedman73a04092012-01-07 04:59:52 +00001220 DC = DC->getParent();
1221 } else if (isa<CXXMethodDecl>(DC) &&
Douglas Gregor1a22d282012-02-12 17:34:23 +00001222 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
Eli Friedman73a04092012-01-07 04:59:52 +00001223 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1224 DC = DC->getParent()->getParent();
1225 }
1226 else break;
1227 }
Mike Stump11289f42009-09-09 15:08:12 +00001228
Anders Carlssonb26ab812009-08-08 17:45:02 +00001229 return DC;
1230}
1231
Chris Lattner79413952008-12-04 23:50:19 +00001232/// getCurFunctionDecl - If inside of a function body, this returns a pointer
1233/// to the function decl for the function being parsed. If we're currently
1234/// in a 'block', this returns the containing context.
1235FunctionDecl *Sema::getCurFunctionDecl() {
Anders Carlssonb26ab812009-08-08 17:45:02 +00001236 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner79413952008-12-04 23:50:19 +00001237 return dyn_cast<FunctionDecl>(DC);
1238}
1239
Daniel Dunbar6e8aa532008-08-11 05:35:13 +00001240ObjCMethodDecl *Sema::getCurMethodDecl() {
Anders Carlssonb26ab812009-08-08 17:45:02 +00001241 DeclContext *DC = getFunctionLevelDeclContext();
Fariborz Jahaniandeac9ac2013-05-31 21:51:12 +00001242 while (isa<RecordDecl>(DC))
1243 DC = DC->getParent();
Steve Naroffecf2bb82008-11-17 16:28:52 +00001244 return dyn_cast<ObjCMethodDecl>(DC);
Daniel Dunbar6e8aa532008-08-11 05:35:13 +00001245}
Chris Lattner79413952008-12-04 23:50:19 +00001246
1247NamedDecl *Sema::getCurFunctionOrMethodDecl() {
Anders Carlssonb26ab812009-08-08 17:45:02 +00001248 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner79413952008-12-04 23:50:19 +00001249 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
Douglas Gregor6e6ad602009-01-20 01:17:11 +00001250 return cast<NamedDecl>(DC);
Craig Topperc3ec1492014-05-26 06:22:03 +00001251 return nullptr;
Chris Lattner79413952008-12-04 23:50:19 +00001252}
1253
Daniel Dunbard671ab92012-03-14 09:49:32 +00001254void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1255 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1256 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1257 // been made more painfully obvious by the refactor that introduced this
1258 // function, but it is possible that the incoming argument can be
Richard Smith51ec0cf2017-02-21 01:17:38 +00001259 // eliminated. If it truly cannot be (for example, there is some reentrancy
Daniel Dunbard671ab92012-03-14 09:49:32 +00001260 // issue I am not seeing yet), then there should at least be a clarifying
1261 // comment somewhere.
David Blaikie05785d12013-02-20 22:23:23 +00001262 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
Daniel Dunbard671ab92012-03-14 09:49:32 +00001263 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
1264 Diags.getCurrentDiagID())) {
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00001265 case DiagnosticIDs::SFINAE_Report:
Richard Smith38c0e042011-10-19 00:07:01 +00001266 // We'll report the diagnostic below.
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001267 break;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001268
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00001269 case DiagnosticIDs::SFINAE_SubstitutionFailure:
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001270 // Count this failure so that we know that template argument deduction
1271 // has failed.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001272 ++NumSFINAEErrors;
Richard Smith9ca64612012-05-07 09:03:25 +00001273
1274 // Make a copy of this suppressed diagnostic and store it with the
1275 // template-deduction information.
1276 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1277 Diagnostic DiagInfo(&Diags);
1278 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1279 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1280 }
1281
Daniel Dunbard671ab92012-03-14 09:49:32 +00001282 Diags.setLastDiagnosticIgnored();
1283 Diags.Clear();
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001284 return;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001285
Richard Smith38c0e042011-10-19 00:07:01 +00001286 case DiagnosticIDs::SFINAE_AccessControl: {
1287 // Per C++ Core Issue 1170, access control is part of SFINAE.
Daniel Dunbara25002f2012-03-13 18:30:54 +00001288 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
Richard Smith38c0e042011-10-19 00:07:01 +00001289 // make access control a part of SFINAE for the purposes of checking
1290 // type traits.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001291 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
Richard Smith38c0e042011-10-19 00:07:01 +00001292 break;
1293
Daniel Dunbard671ab92012-03-14 09:49:32 +00001294 SourceLocation Loc = Diags.getCurrentDiagLoc();
Richard Smith38c0e042011-10-19 00:07:01 +00001295
1296 // Suppress this diagnostic.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001297 ++NumSFINAEErrors;
Richard Smith9ca64612012-05-07 09:03:25 +00001298
1299 // Make a copy of this suppressed diagnostic and store it with the
1300 // template-deduction information.
1301 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1302 Diagnostic DiagInfo(&Diags);
1303 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1304 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1305 }
1306
Daniel Dunbard671ab92012-03-14 09:49:32 +00001307 Diags.setLastDiagnosticIgnored();
1308 Diags.Clear();
Richard Smith38c0e042011-10-19 00:07:01 +00001309
1310 // Now the diagnostic state is clear, produce a C++98 compatibility
1311 // warning.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001312 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
Richard Smith38c0e042011-10-19 00:07:01 +00001313
1314 // The last diagnostic which Sema produced was ignored. Suppress any
1315 // notes attached to it.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001316 Diags.setLastDiagnosticIgnored();
Richard Smith38c0e042011-10-19 00:07:01 +00001317 return;
1318 }
1319
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00001320 case DiagnosticIDs::SFINAE_Suppress:
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001321 // Make a copy of this suppressed diagnostic and store it with the
1322 // template-deduction information;
Richard Smith9ca64612012-05-07 09:03:25 +00001323 if (*Info) {
1324 Diagnostic DiagInfo(&Diags);
Douglas Gregoredb76852011-01-27 22:31:44 +00001325 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
Richard Smith9ca64612012-05-07 09:03:25 +00001326 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1327 }
1328
1329 // Suppress this diagnostic.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001330 Diags.setLastDiagnosticIgnored();
1331 Diags.Clear();
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001332 return;
1333 }
1334 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001335
Joel E. Denny7bcc2102018-05-14 18:41:44 +00001336 // Copy the diagnostic printing policy over the ASTContext printing policy.
1337 // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
Daniel Dunbard671ab92012-03-14 09:49:32 +00001338 Context.setPrintingPolicy(getPrintingPolicy());
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001339
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001340 // Emit the diagnostic.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001341 if (!Diags.EmitCurrentDiagnostic())
Douglas Gregor33834512009-06-14 07:33:30 +00001342 return;
Mike Stump11289f42009-09-09 15:08:12 +00001343
Douglas Gregorda17bd32009-03-20 22:48:49 +00001344 // If this is not a note, and we're in a template instantiation
1345 // that is different from the last template instantiation where
1346 // we emitted an error, print a template instantiation
1347 // backtrace.
Richard Smith51ec0cf2017-02-21 01:17:38 +00001348 if (!DiagnosticIDs::isBuiltinNote(DiagID))
1349 PrintContextStack();
Douglas Gregorda17bd32009-03-20 22:48:49 +00001350}
Douglas Gregorc6d5edd2009-07-02 17:08:52 +00001351
Anders Carlssonf68079e2009-08-26 22:33:56 +00001352Sema::SemaDiagnosticBuilder
1353Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
1354 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1355 PD.Emit(Builder);
Mike Stump11289f42009-09-09 15:08:12 +00001356
Anders Carlssonf68079e2009-08-26 22:33:56 +00001357 return Builder;
1358}
1359
Alexey Bataev89721332019-02-07 19:46:42 +00001360// Print notes showing how we can reach FD starting from an a priori
1361// known-callable function.
1362static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
1363 auto FnIt = S.DeviceKnownEmittedFns.find(FD);
1364 while (FnIt != S.DeviceKnownEmittedFns.end()) {
1365 DiagnosticBuilder Builder(
1366 S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
1367 Builder << FnIt->second.FD;
1368 Builder.setForceEmit();
1369
1370 FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
1371 }
1372}
1373
1374// Emit any deferred diagnostics for FD and erase them from the map in which
1375// they're stored.
1376static void emitDeferredDiags(Sema &S, FunctionDecl *FD) {
1377 auto It = S.DeviceDeferredDiags.find(FD);
1378 if (It == S.DeviceDeferredDiags.end())
1379 return;
1380 bool HasWarningOrError = false;
1381 for (PartialDiagnosticAt &PDAt : It->second) {
1382 const SourceLocation &Loc = PDAt.first;
1383 const PartialDiagnostic &PD = PDAt.second;
1384 HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
1385 PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
1386 DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
1387 Builder.setForceEmit();
1388 PD.Emit(Builder);
1389 }
1390 S.DeviceDeferredDiags.erase(It);
1391
1392 // FIXME: Should this be called after every warning/error emitted in the loop
1393 // above, instead of just once per function? That would be consistent with
1394 // how we handle immediate errors, but it also seems like a bit much.
1395 if (HasWarningOrError)
1396 emitCallStackNotes(S, FD);
1397}
1398
1399// In CUDA, there are some constructs which may appear in semantically-valid
1400// code, but trigger errors if we ever generate code for the function in which
1401// they appear. Essentially every construct you're not allowed to use on the
1402// device falls into this category, because you are allowed to use these
1403// constructs in a __host__ __device__ function, but only if that function is
1404// never codegen'ed on the device.
1405//
1406// To handle semantic checking for these constructs, we keep track of the set of
1407// functions we know will be emitted, either because we could tell a priori that
1408// they would be emitted, or because they were transitively called by a
1409// known-emitted function.
1410//
1411// We also keep a partial call graph of which not-known-emitted functions call
1412// which other not-known-emitted functions.
1413//
1414// When we see something which is illegal if the current function is emitted
1415// (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
1416// CheckCUDACall), we first check if the current function is known-emitted. If
1417// so, we immediately output the diagnostic.
1418//
1419// Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags
1420// until we discover that the function is known-emitted, at which point we take
1421// it out of this map and emit the diagnostic.
1422
1423Sema::DeviceDiagBuilder::DeviceDiagBuilder(Kind K, SourceLocation Loc,
1424 unsigned DiagID, FunctionDecl *Fn,
1425 Sema &S)
1426 : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
1427 ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
1428 switch (K) {
1429 case K_Nop:
1430 break;
1431 case K_Immediate:
1432 case K_ImmediateWithCallStack:
1433 ImmediateDiag.emplace(S.Diag(Loc, DiagID));
1434 break;
1435 case K_Deferred:
1436 assert(Fn && "Must have a function to attach the deferred diag to.");
Alexey Bataev3167b302019-02-22 14:42:48 +00001437 auto &Diags = S.DeviceDeferredDiags[Fn];
1438 PartialDiagId.emplace(Diags.size());
1439 Diags.emplace_back(Loc, S.PDiag(DiagID));
Alexey Bataev89721332019-02-07 19:46:42 +00001440 break;
1441 }
1442}
1443
Alexey Bataeve69f94e2019-02-22 20:36:10 +00001444Sema::DeviceDiagBuilder::DeviceDiagBuilder(DeviceDiagBuilder &&D)
1445 : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),
1446 ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),
1447 PartialDiagId(D.PartialDiagId) {
1448 // Clean the previous diagnostics.
1449 D.ShowCallStack = false;
1450 D.ImmediateDiag.reset();
1451 D.PartialDiagId.reset();
1452}
1453
Alexey Bataev89721332019-02-07 19:46:42 +00001454Sema::DeviceDiagBuilder::~DeviceDiagBuilder() {
1455 if (ImmediateDiag) {
1456 // Emit our diagnostic and, if it was a warning or error, output a callstack
1457 // if Fn isn't a priori known-emitted.
1458 bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
1459 DiagID, Loc) >= DiagnosticsEngine::Warning;
1460 ImmediateDiag.reset(); // Emit the immediate diag.
1461 if (IsWarningOrError && ShowCallStack)
1462 emitCallStackNotes(S, Fn);
Alexey Bataev3167b302019-02-22 14:42:48 +00001463 } else {
1464 assert((!PartialDiagId || ShowCallStack) &&
1465 "Must always show call stack for deferred diags.");
Alexey Bataev89721332019-02-07 19:46:42 +00001466 }
1467}
1468
1469// Indicate that this function (and thus everything it transtively calls) will
1470// be codegen'ed, and emit any deferred diagnostics on this function and its
1471// (transitive) callees.
1472void Sema::markKnownEmitted(
1473 Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
1474 SourceLocation OrigLoc,
1475 const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted) {
1476 // Nothing to do if we already know that FD is emitted.
1477 if (IsKnownEmitted(S, OrigCallee)) {
1478 assert(!S.DeviceCallGraph.count(OrigCallee));
1479 return;
1480 }
1481
1482 // We've just discovered that OrigCallee is known-emitted. Walk our call
1483 // graph to see what else we can now discover also must be emitted.
1484
1485 struct CallInfo {
1486 FunctionDecl *Caller;
1487 FunctionDecl *Callee;
1488 SourceLocation Loc;
1489 };
1490 llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
1491 llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
1492 Seen.insert(OrigCallee);
1493 while (!Worklist.empty()) {
1494 CallInfo C = Worklist.pop_back_val();
1495 assert(!IsKnownEmitted(S, C.Callee) &&
1496 "Worklist should not contain known-emitted functions.");
1497 S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
1498 emitDeferredDiags(S, C.Callee);
1499
1500 // If this is a template instantiation, explore its callgraph as well:
1501 // Non-dependent calls are part of the template's callgraph, while dependent
1502 // calls are part of to the instantiation's call graph.
1503 if (auto *Templ = C.Callee->getPrimaryTemplate()) {
1504 FunctionDecl *TemplFD = Templ->getAsFunction();
1505 if (!Seen.count(TemplFD) && !S.DeviceKnownEmittedFns.count(TemplFD)) {
1506 Seen.insert(TemplFD);
1507 Worklist.push_back(
1508 {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
1509 }
1510 }
1511
1512 // Add all functions called by Callee to our worklist.
1513 auto CGIt = S.DeviceCallGraph.find(C.Callee);
1514 if (CGIt == S.DeviceCallGraph.end())
1515 continue;
1516
1517 for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
1518 CGIt->second) {
1519 FunctionDecl *NewCallee = FDLoc.first;
1520 SourceLocation CallLoc = FDLoc.second;
1521 if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
1522 continue;
1523 Seen.insert(NewCallee);
1524 Worklist.push_back(
1525 {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
1526 }
1527
1528 // C.Callee is now known-emitted, so we no longer need to maintain its list
1529 // of callees in DeviceCallGraph.
1530 S.DeviceCallGraph.erase(CGIt);
1531 }
1532}
1533
Alexey Bataev3167b302019-02-22 14:42:48 +00001534Sema::DeviceDiagBuilder Sema::targetDiag(SourceLocation Loc, unsigned DiagID) {
Alexey Bataev5c96c1c2019-02-20 17:42:57 +00001535 if (LangOpts.OpenMP && LangOpts.OpenMPIsDevice)
1536 return diagIfOpenMPDeviceCode(Loc, DiagID);
Alexey Bataev3167b302019-02-22 14:42:48 +00001537 if (getLangOpts().CUDA)
1538 return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID)
1539 : CUDADiagIfHostCode(Loc, DiagID);
Alexey Bataev5c96c1c2019-02-20 17:42:57 +00001540 return DeviceDiagBuilder(DeviceDiagBuilder::K_Immediate, Loc, DiagID,
1541 getCurFunctionDecl(), *this);
1542}
1543
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001544/// Looks through the macro-expansion chain for the given
Chandler Carruthc22845a2011-07-26 05:40:03 +00001545/// location, looking for a macro expansion with the given name.
John McCall462c0552011-03-08 07:59:04 +00001546/// If one is found, returns true and sets the location to that
Chandler Carruthc22845a2011-07-26 05:40:03 +00001547/// expansion loc.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001548bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
John McCall462c0552011-03-08 07:59:04 +00001549 SourceLocation loc = locref;
1550 if (!loc.isMacroID()) return false;
1551
1552 // There's no good way right now to look at the intermediate
Chandler Carruthc22845a2011-07-26 05:40:03 +00001553 // expansions, so just jump to the expansion location.
Chandler Carruth35f53202011-07-25 16:49:02 +00001554 loc = getSourceManager().getExpansionLoc(loc);
John McCall462c0552011-03-08 07:59:04 +00001555
1556 // If that's written with the name, stop here.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001557 SmallVector<char, 16> buffer;
John McCall462c0552011-03-08 07:59:04 +00001558 if (getPreprocessor().getSpelling(loc, buffer) == name) {
1559 locref = loc;
1560 return true;
1561 }
1562 return false;
1563}
1564
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001565/// Determines the active Scope associated with the given declaration
Douglas Gregor0be31a22010-07-02 17:43:08 +00001566/// context.
1567///
1568/// This routine maps a declaration context to the active Scope object that
1569/// represents that declaration context in the parser. It is typically used
1570/// from "scope-less" code (e.g., template instantiation, lazy creation of
1571/// declarations) that injects a name for name-lookup purposes and, therefore,
1572/// must update the Scope.
1573///
1574/// \returns The scope corresponding to the given declaraion context, or NULL
1575/// if no such scope is open.
1576Scope *Sema::getScopeForContext(DeclContext *Ctx) {
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001577
Douglas Gregor0be31a22010-07-02 17:43:08 +00001578 if (!Ctx)
Craig Topperc3ec1492014-05-26 06:22:03 +00001579 return nullptr;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001580
Douglas Gregor0be31a22010-07-02 17:43:08 +00001581 Ctx = Ctx->getPrimaryContext();
1582 for (Scope *S = getCurScope(); S; S = S->getParent()) {
Sebastian Redlcaef9ab2010-07-08 23:07:34 +00001583 // Ignore scopes that cannot have declarations. This is important for
1584 // out-of-line definitions of static class members.
1585 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
Ted Kremenekc37877d2013-10-08 17:08:03 +00001586 if (DeclContext *Entity = S->getEntity())
Sebastian Redlcaef9ab2010-07-08 23:07:34 +00001587 if (Ctx == Entity->getPrimaryContext())
1588 return S;
Douglas Gregor0be31a22010-07-02 17:43:08 +00001589 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001590
Craig Topperc3ec1492014-05-26 06:22:03 +00001591 return nullptr;
Douglas Gregor0be31a22010-07-02 17:43:08 +00001592}
Douglas Gregor9a28e842010-03-01 23:15:13 +00001593
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001594/// Enter a new function scope
Douglas Gregor9a28e842010-03-01 23:15:13 +00001595void Sema::PushFunctionScope() {
Richard Smith2fdd95c2019-05-31 00:45:09 +00001596 if (FunctionScopes.empty() && CachedFunctionScope) {
1597 // Use CachedFunctionScope to avoid allocating memory when possible.
1598 CachedFunctionScope->Clear();
1599 FunctionScopes.push_back(CachedFunctionScope.release());
Reid Kleckner87a31802018-03-12 21:43:02 +00001600 } else {
1601 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
Douglas Gregor9a28e842010-03-01 23:15:13 +00001602 }
Alexey Bataev4b465392017-04-26 15:06:24 +00001603 if (LangOpts.OpenMP)
1604 pushOpenMPFunctionRegion();
Douglas Gregor9a28e842010-03-01 23:15:13 +00001605}
1606
1607void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
Argyrios Kyrtzidisf51ec1d2010-11-19 00:19:15 +00001608 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
Douglas Gregor9a28e842010-03-01 23:15:13 +00001609 BlockScope, Block));
1610}
1611
Faisal Vali97d8c332013-11-12 01:46:33 +00001612LambdaScopeInfo *Sema::PushLambdaScope() {
Faisal Vali524ca282013-11-12 01:40:44 +00001613 LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1614 FunctionScopes.push_back(LSI);
1615 return LSI;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001616}
1617
1618void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {
1619 if (LambdaScopeInfo *const LSI = getCurLambda()) {
1620 LSI->AutoTemplateParameterDepth = Depth;
1621 return;
Reid Kleckner87a31802018-03-12 21:43:02 +00001622 }
1623 llvm_unreachable(
Faisal Vali2b391ab2013-09-26 19:54:12 +00001624 "Remove assertion if intentionally called in a non-lambda context.");
Eli Friedman71c80552012-01-05 03:35:19 +00001625}
1626
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001627// Check that the type of the VarDecl has an accessible copy constructor and
JF Bastienea51a8c2019-04-30 00:19:43 +00001628// resolve its destructor's exception specification.
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001629static void checkEscapingByref(VarDecl *VD, Sema &S) {
1630 QualType T = VD->getType();
1631 EnterExpressionEvaluationContext scope(
1632 S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1633 SourceLocation Loc = VD->getLocation();
Bruno Ricci5fc4db72018-12-21 14:10:18 +00001634 Expr *VarRef =
1635 new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001636 ExprResult Result = S.PerformMoveOrCopyInitialization(
1637 InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1638 VarRef, /*AllowNRVO=*/true);
1639 if (!Result.isInvalid()) {
1640 Result = S.MaybeCreateExprWithCleanups(Result);
1641 Expr *Init = Result.getAs<Expr>();
1642 S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1643 }
1644
JF Bastienea51a8c2019-04-30 00:19:43 +00001645 // The destructor's exception specification is needed when IRGen generates
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001646 // block copy/destroy functions. Resolve it here.
1647 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1648 if (CXXDestructorDecl *DD = RD->getDestructor()) {
1649 auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1650 S.ResolveExceptionSpec(Loc, FPT);
1651 }
1652}
1653
1654static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1655 // Set the EscapingByref flag of __block variables captured by
1656 // escaping blocks.
1657 for (const BlockDecl *BD : FSI.Blocks) {
1658 if (BD->doesNotEscape())
1659 continue;
1660 for (const BlockDecl::Capture &BC : BD->captures()) {
1661 VarDecl *VD = BC.getVariable();
1662 if (VD->hasAttr<BlocksAttr>())
1663 VD->setEscapingByref();
1664 }
1665 }
1666
1667 for (VarDecl *VD : FSI.ByrefBlockVars) {
1668 // __block variables might require us to capture a copy-initializer.
1669 if (!VD->isEscapingByref())
1670 continue;
1671 // It's currently invalid to ever have a __block variable with an
1672 // array type; should we diagnose that here?
1673 // Regardless, we don't want to ignore array nesting when
1674 // constructing this copy.
1675 if (VD->getType()->isStructureOrClassType())
1676 checkEscapingByref(VD, S);
1677 }
1678}
1679
Richard Smith2fdd95c2019-05-31 00:45:09 +00001680/// Pop a function (or block or lambda or captured region) scope from the stack.
1681///
1682/// \param WP The warning policy to use for CFG-based warnings, or null if such
1683/// warnings should not be produced.
1684/// \param D The declaration corresponding to this function scope, if producing
1685/// CFG-based warnings.
1686/// \param BlockType The type of the block expression, if D is a BlockDecl.
1687Sema::PoppedFunctionScopePtr
1688Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1689 const Decl *D, QualType BlockType) {
Reid Kleckner8d485b82018-03-08 01:12:22 +00001690 assert(!FunctionScopes.empty() && "mismatched push/pop!");
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001691
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001692 markEscapingByrefs(*FunctionScopes.back(), *this);
1693
Richard Smith2fdd95c2019-05-31 00:45:09 +00001694 PoppedFunctionScopePtr Scope(FunctionScopes.pop_back_val(),
1695 PoppedFunctionScopeDeleter(this));
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001696
Alexey Bataev4b465392017-04-26 15:06:24 +00001697 if (LangOpts.OpenMP)
Richard Smith2fdd95c2019-05-31 00:45:09 +00001698 popOpenMPFunctionRegion(Scope.get());
Alexey Bataev4b465392017-04-26 15:06:24 +00001699
Ted Kremenek1767a272011-02-23 01:51:48 +00001700 // Issue any analysis-based warnings.
1701 if (WP && D)
Richard Smith2fdd95c2019-05-31 00:45:09 +00001702 AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
Aaron Ballman130a3b02014-05-15 20:58:55 +00001703 else
1704 for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1705 Diag(PUD.Loc, PUD.PD);
Ted Kremenek1767a272011-02-23 01:51:48 +00001706
Richard Smith2fdd95c2019-05-31 00:45:09 +00001707 return Scope;
1708}
1709
1710void Sema::PoppedFunctionScopeDeleter::
1711operator()(sema::FunctionScopeInfo *Scope) const {
1712 // Stash the function scope for later reuse if it's for a normal function.
1713 if (Scope->isPlainFunction() && !Self->CachedFunctionScope)
1714 Self->CachedFunctionScope.reset(Scope);
1715 else
John McCallaab3e412010-08-25 08:40:02 +00001716 delete Scope;
Douglas Gregor9a28e842010-03-01 23:15:13 +00001717}
1718
Richard Smith6eb9b9e2018-02-03 00:44:57 +00001719void Sema::PushCompoundScope(bool IsStmtExpr) {
1720 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
Dmitri Gribenko800ddf32012-02-14 22:14:32 +00001721}
1722
1723void Sema::PopCompoundScope() {
1724 FunctionScopeInfo *CurFunction = getCurFunction();
1725 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1726
1727 CurFunction->CompoundScopes.pop_back();
1728}
1729
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001730/// Determine whether any errors occurred within this function/method/
Douglas Gregor9a28e842010-03-01 23:15:13 +00001731/// block.
John McCall31168b02011-06-15 23:02:42 +00001732bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1733 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
Douglas Gregor9a28e842010-03-01 23:15:13 +00001734}
1735
Reid Kleckner87a31802018-03-12 21:43:02 +00001736void Sema::setFunctionHasBranchIntoScope() {
1737 if (!FunctionScopes.empty())
1738 FunctionScopes.back()->setHasBranchIntoScope();
1739}
1740
1741void Sema::setFunctionHasBranchProtectedScope() {
1742 if (!FunctionScopes.empty())
1743 FunctionScopes.back()->setHasBranchProtectedScope();
1744}
1745
1746void Sema::setFunctionHasIndirectGoto() {
1747 if (!FunctionScopes.empty())
1748 FunctionScopes.back()->setHasIndirectGoto();
1749}
1750
Douglas Gregor9a28e842010-03-01 23:15:13 +00001751BlockScopeInfo *Sema::getCurBlock() {
1752 if (FunctionScopes.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00001753 return nullptr;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001754
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001755 auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1756 if (CurBSI && CurBSI->TheDecl &&
1757 !CurBSI->TheDecl->Encloses(CurContext)) {
1758 // We have switched contexts due to template instantiation.
Richard Smith696e3122017-02-23 01:43:54 +00001759 assert(!CodeSynthesisContexts.empty());
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001760 return nullptr;
1761 }
1762
1763 return CurBSI;
Douglas Gregor9a28e842010-03-01 23:15:13 +00001764}
John McCall75b960e2010-06-01 09:23:16 +00001765
Reid Kleckner04f9bca2018-03-07 22:48:35 +00001766FunctionScopeInfo *Sema::getEnclosingFunction() const {
1767 if (FunctionScopes.empty())
1768 return nullptr;
1769
1770 for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1771 if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1772 continue;
1773 return FunctionScopes[e];
1774 }
1775 return nullptr;
1776}
1777
Akira Hatanaka7cbbb882017-03-01 06:11:25 +00001778LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
Eli Friedman4817cf72012-01-06 03:05:34 +00001779 if (FunctionScopes.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00001780 return nullptr;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001781
Alexey Bataev31939e32016-11-11 12:36:20 +00001782 auto I = FunctionScopes.rbegin();
Akira Hatanaka7cbbb882017-03-01 06:11:25 +00001783 if (IgnoreNonLambdaCapturingScope) {
Alexey Bataev31939e32016-11-11 12:36:20 +00001784 auto E = FunctionScopes.rend();
Akira Hatanaka7cbbb882017-03-01 06:11:25 +00001785 while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
Alexey Bataev31939e32016-11-11 12:36:20 +00001786 ++I;
1787 if (I == E)
1788 return nullptr;
1789 }
1790 auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001791 if (CurLSI && CurLSI->Lambda &&
1792 !CurLSI->Lambda->Encloses(CurContext)) {
1793 // We have switched contexts due to template instantiation.
Richard Smith696e3122017-02-23 01:43:54 +00001794 assert(!CodeSynthesisContexts.empty());
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001795 return nullptr;
1796 }
1797
1798 return CurLSI;
Eli Friedman4817cf72012-01-06 03:05:34 +00001799}
Fangrui Song6907ce22018-07-30 19:24:48 +00001800// We have a generic lambda if we parsed auto parameters, or we have
Faisal Vali2b391ab2013-09-26 19:54:12 +00001801// an associated template parameter list.
1802LambdaScopeInfo *Sema::getCurGenericLambda() {
1803 if (LambdaScopeInfo *LSI = getCurLambda()) {
Hamza Sood8205a812019-05-04 10:49:46 +00001804 return (LSI->TemplateParams.size() ||
Craig Topperc3ec1492014-05-26 06:22:03 +00001805 LSI->GLTemplateParameterList) ? LSI : nullptr;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001806 }
Craig Topperc3ec1492014-05-26 06:22:03 +00001807 return nullptr;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001808}
1809
Eli Friedman4817cf72012-01-06 03:05:34 +00001810
Dmitri Gribenkoaab83832012-06-20 00:34:58 +00001811void Sema::ActOnComment(SourceRange Comment) {
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00001812 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1813 SourceMgr.isInSystemHeader(Comment.getBegin()))
1814 return;
David L. Jones13d5a872018-03-02 00:07:45 +00001815 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
Dmitri Gribenko052f60d2012-06-22 16:02:55 +00001816 if (RC.isAlmostTrailingComment()) {
1817 SourceRange MagicMarkerRange(Comment.getBegin(),
1818 Comment.getBegin().getLocWithOffset(3));
1819 StringRef MagicMarkerText;
1820 switch (RC.getKind()) {
Abramo Bagnarae06a8882012-07-04 07:30:26 +00001821 case RawComment::RCK_OrdinaryBCPL:
Dmitri Gribenko052f60d2012-06-22 16:02:55 +00001822 MagicMarkerText = "///<";
1823 break;
Abramo Bagnarae06a8882012-07-04 07:30:26 +00001824 case RawComment::RCK_OrdinaryC:
Dmitri Gribenko052f60d2012-06-22 16:02:55 +00001825 MagicMarkerText = "/**<";
1826 break;
1827 default:
1828 llvm_unreachable("if this is an almost Doxygen comment, "
1829 "it should be ordinary");
1830 }
1831 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1832 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1833 }
Dmitri Gribenkoaab83832012-06-20 00:34:58 +00001834 Context.addComment(RC);
1835}
1836
John McCall75b960e2010-06-01 09:23:16 +00001837// Pin this vtable to this file.
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +00001838ExternalSemaSource::~ExternalSemaSource() {}
John McCallfaf5fb42010-08-26 23:41:50 +00001839
Douglas Gregore1716012012-01-25 00:49:42 +00001840void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
Manman Rena0f31a02016-04-29 19:04:05 +00001841void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { }
Sebastian Redlc1ca90a2010-09-28 20:23:00 +00001842
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001843void ExternalSemaSource::ReadKnownNamespaces(
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001844 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001845}
1846
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00001847void ExternalSemaSource::ReadUndefinedButUsed(
Richard Smithd6a04d72016-03-25 21:49:43 +00001848 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
Nick Lewycky8334af82013-01-26 00:35:08 +00001849
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00001850void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<
1851 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1852
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001853/// Figure out if an expression could be turned into a call.
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001854///
1855/// Use this when trying to recover from an error where the programmer may have
1856/// written just the name of a function instead of actually calling it.
1857///
1858/// \param E - The expression to examine.
1859/// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1860/// with no arguments, this parameter is set to the type returned by such a
1861/// call; otherwise, it is set to an empty QualType.
John McCall50a2c2c2011-10-11 23:14:30 +00001862/// \param OverloadSet - If the expression is an overloaded function
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001863/// name, this parameter is populated with the decls of the various overloads.
David Blaikiee5323aa2013-06-21 23:54:45 +00001864bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1865 UnresolvedSetImpl &OverloadSet) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001866 ZeroArgCallReturnTy = QualType();
John McCall50a2c2c2011-10-11 23:14:30 +00001867 OverloadSet.clear();
1868
Craig Topperc3ec1492014-05-26 06:22:03 +00001869 const OverloadExpr *Overloads = nullptr;
David Blaikiee5323aa2013-06-21 23:54:45 +00001870 bool IsMemExpr = false;
John McCall50a2c2c2011-10-11 23:14:30 +00001871 if (E.getType() == Context.OverloadTy) {
1872 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
John McCall50a2c2c2011-10-11 23:14:30 +00001873
David Blaikie6df859d82013-06-04 00:28:46 +00001874 // Ignore overloads that are pointer-to-member constants.
1875 if (FR.HasFormOfMemberPointer)
1876 return false;
1877
1878 Overloads = FR.Expression;
1879 } else if (E.getType() == Context.BoundMemberTy) {
1880 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
David Blaikiee5323aa2013-06-21 23:54:45 +00001881 IsMemExpr = true;
David Blaikie6df859d82013-06-04 00:28:46 +00001882 }
David Blaikiee5323aa2013-06-21 23:54:45 +00001883
1884 bool Ambiguous = false;
Erich Keane3efe0022018-07-20 14:13:28 +00001885 bool IsMV = false;
David Blaikiee5323aa2013-06-21 23:54:45 +00001886
David Blaikie6df859d82013-06-04 00:28:46 +00001887 if (Overloads) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001888 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1889 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
John McCall50a2c2c2011-10-11 23:14:30 +00001890 OverloadSet.addDecl(*it);
1891
David Blaikiee5323aa2013-06-21 23:54:45 +00001892 // Check whether the function is a non-template, non-member which takes no
John McCall50a2c2c2011-10-11 23:14:30 +00001893 // arguments.
David Blaikiee5323aa2013-06-21 23:54:45 +00001894 if (IsMemExpr)
1895 continue;
John McCall50a2c2c2011-10-11 23:14:30 +00001896 if (const FunctionDecl *OverloadDecl
1897 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
David Blaikie6df859d82013-06-04 00:28:46 +00001898 if (OverloadDecl->getMinRequiredArguments() == 0) {
Erich Keane3efe0022018-07-20 14:13:28 +00001899 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1900 (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1901 OverloadDecl->isCPUSpecificMultiVersion()))) {
David Blaikie6df859d82013-06-04 00:28:46 +00001902 ZeroArgCallReturnTy = QualType();
1903 Ambiguous = true;
Erich Keane3efe0022018-07-20 14:13:28 +00001904 } else {
Alp Toker314cc812014-01-25 16:55:45 +00001905 ZeroArgCallReturnTy = OverloadDecl->getReturnType();
Erich Keane3efe0022018-07-20 14:13:28 +00001906 IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1907 OverloadDecl->isCPUSpecificMultiVersion();
1908 }
David Blaikie6df859d82013-06-04 00:28:46 +00001909 }
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001910 }
1911 }
John McCall50a2c2c2011-10-11 23:14:30 +00001912
David Blaikiee5323aa2013-06-21 23:54:45 +00001913 // If it's not a member, use better machinery to try to resolve the call
1914 if (!IsMemExpr)
1915 return !ZeroArgCallReturnTy.isNull();
1916 }
1917
1918 // Attempt to call the member with no arguments - this will correctly handle
1919 // member templates with defaults/deduction of template arguments, overloads
1920 // with default arguments, etc.
Eli Friedman544c9562013-07-08 23:35:04 +00001921 if (IsMemExpr && !E.isTypeDependent()) {
David Blaikiee5323aa2013-06-21 23:54:45 +00001922 bool Suppress = getDiagnostics().getSuppressAllDiagnostics();
1923 getDiagnostics().setSuppressAllDiagnostics(true);
Craig Topperc3ec1492014-05-26 06:22:03 +00001924 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(),
1925 None, SourceLocation());
David Blaikiee5323aa2013-06-21 23:54:45 +00001926 getDiagnostics().setSuppressAllDiagnostics(Suppress);
1927 if (R.isUsable()) {
1928 ZeroArgCallReturnTy = R.get()->getType();
1929 return true;
1930 }
1931 return false;
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001932 }
1933
John McCall50a2c2c2011-10-11 23:14:30 +00001934 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001935 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
1936 if (Fun->getMinRequiredArguments() == 0)
Alp Toker314cc812014-01-25 16:55:45 +00001937 ZeroArgCallReturnTy = Fun->getReturnType();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001938 return true;
1939 }
1940 }
1941
1942 // We don't have an expression that's convenient to get a FunctionDecl from,
1943 // but we can at least check if the type is "function of 0 arguments".
1944 QualType ExprTy = E.getType();
Craig Topperc3ec1492014-05-26 06:22:03 +00001945 const FunctionType *FunTy = nullptr;
Matt Beaumont-Gay330a5b42011-05-05 00:59:35 +00001946 QualType PointeeTy = ExprTy->getPointeeType();
1947 if (!PointeeTy.isNull())
1948 FunTy = PointeeTy->getAs<FunctionType>();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001949 if (!FunTy)
1950 FunTy = ExprTy->getAs<FunctionType>();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001951
1952 if (const FunctionProtoType *FPT =
1953 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
Alp Toker9cacbab2014-01-20 20:26:09 +00001954 if (FPT->getNumParams() == 0)
Alp Toker314cc812014-01-25 16:55:45 +00001955 ZeroArgCallReturnTy = FunTy->getReturnType();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001956 return true;
1957 }
1958 return false;
1959}
1960
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001961/// Give notes for a set of overloads.
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001962///
David Blaikiee5323aa2013-06-21 23:54:45 +00001963/// A companion to tryExprAsCall. In cases when the name that the programmer
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001964/// wrote was an overloaded function, we may be able to make some guesses about
1965/// plausible overloads based on their return types; such guesses can be handed
1966/// off to this method to be emitted as notes.
1967///
1968/// \param Overloads - The overloads to note.
1969/// \param FinalNoteLoc - If we've suppressed printing some overloads due to
1970/// -fshow-overloads=best, this is the location to attach to the note about too
1971/// many candidates. Typically this will be the location of the original
1972/// ill-formed expression.
John McCall50a2c2c2011-10-11 23:14:30 +00001973static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
1974 const SourceLocation FinalNoteLoc) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001975 int ShownOverloads = 0;
1976 int SuppressedOverloads = 0;
1977 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
1978 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
1979 // FIXME: Magic number for max shown overloads stolen from
1980 // OverloadCandidateSet::NoteCandidates.
Douglas Gregor79591782012-10-23 23:11:23 +00001981 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001982 ++SuppressedOverloads;
1983 continue;
1984 }
John McCall50a2c2c2011-10-11 23:14:30 +00001985
1986 NamedDecl *Fn = (*It)->getUnderlyingDecl();
Erich Keane281d20b2018-01-08 21:34:17 +00001987 // Don't print overloads for non-default multiversioned functions.
1988 if (const auto *FD = Fn->getAsFunction()) {
Erich Keane3efe0022018-07-20 14:13:28 +00001989 if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
Erich Keane281d20b2018-01-08 21:34:17 +00001990 !FD->getAttr<TargetAttr>()->isDefaultVersion())
1991 continue;
1992 }
Abramo Bagnaradc1646d2011-11-15 21:43:28 +00001993 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001994 ++ShownOverloads;
1995 }
John McCall50a2c2c2011-10-11 23:14:30 +00001996
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001997 if (SuppressedOverloads)
John McCall50a2c2c2011-10-11 23:14:30 +00001998 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
1999 << SuppressedOverloads;
2000}
2001
2002static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
2003 const UnresolvedSetImpl &Overloads,
2004 bool (*IsPlausibleResult)(QualType)) {
2005 if (!IsPlausibleResult)
2006 return noteOverloads(S, Overloads, Loc);
2007
2008 UnresolvedSet<2> PlausibleOverloads;
2009 for (OverloadExpr::decls_iterator It = Overloads.begin(),
2010 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2011 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
Alp Toker314cc812014-01-25 16:55:45 +00002012 QualType OverloadResultTy = OverloadDecl->getReturnType();
John McCall50a2c2c2011-10-11 23:14:30 +00002013 if (IsPlausibleResult(OverloadResultTy))
2014 PlausibleOverloads.addDecl(It.getDecl());
2015 }
2016 noteOverloads(S, PlausibleOverloads, Loc);
2017}
2018
2019/// Determine whether the given expression can be called by just
2020/// putting parentheses after it. Notably, expressions with unary
2021/// operators can't be because the unary operator will start parsing
2022/// outside the call.
2023static bool IsCallableWithAppend(Expr *E) {
2024 E = E->IgnoreImplicit();
2025 return (!isa<CStyleCastExpr>(E) &&
2026 !isa<UnaryOperator>(E) &&
2027 !isa<BinaryOperator>(E) &&
2028 !isa<CXXOperatorCallExpr>(E));
2029}
2030
Erich Keane3efe0022018-07-20 14:13:28 +00002031static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {
2032 if (const auto *UO = dyn_cast<UnaryOperator>(E))
2033 E = UO->getSubExpr();
2034
2035 if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2036 if (ULE->getNumDecls() == 0)
2037 return false;
2038
2039 const NamedDecl *ND = *ULE->decls_begin();
2040 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2041 return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
2042 }
2043 return false;
2044}
2045
John McCall50a2c2c2011-10-11 23:14:30 +00002046bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
2047 bool ForceComplain,
2048 bool (*IsPlausibleResult)(QualType)) {
2049 SourceLocation Loc = E.get()->getExprLoc();
2050 SourceRange Range = E.get()->getSourceRange();
2051
2052 QualType ZeroArgCallTy;
2053 UnresolvedSet<4> Overloads;
David Blaikiee5323aa2013-06-21 23:54:45 +00002054 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
John McCall50a2c2c2011-10-11 23:14:30 +00002055 !ZeroArgCallTy.isNull() &&
2056 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
2057 // At this point, we know E is potentially callable with 0
2058 // arguments and that it returns something of a reasonable type,
2059 // so we can emit a fixit and carry on pretending that E was
2060 // actually a CallExpr.
Craig Topper07fa1762015-11-15 02:31:46 +00002061 SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
Erich Keane3efe0022018-07-20 14:13:28 +00002062 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2063 Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
2064 << (IsCallableWithAppend(E.get())
2065 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
2066 : FixItHint());
2067 if (!IsMV)
2068 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
John McCall50a2c2c2011-10-11 23:14:30 +00002069
2070 // FIXME: Try this before emitting the fixit, and suppress diagnostics
2071 // while doing so.
Richard Smith255b85f2019-05-08 01:36:36 +00002072 E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None,
Nick Lewycky1e43d952013-08-21 19:09:44 +00002073 Range.getEnd().getLocWithOffset(1));
John McCall50a2c2c2011-10-11 23:14:30 +00002074 return true;
2075 }
2076
2077 if (!ForceComplain) return false;
2078
Erich Keane3efe0022018-07-20 14:13:28 +00002079 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2080 Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
2081 if (!IsMV)
2082 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
John McCall50a2c2c2011-10-11 23:14:30 +00002083 E = ExprError();
2084 return true;
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002085}
Argyrios Kyrtzidis3e56dd42013-03-14 22:56:43 +00002086
2087IdentifierInfo *Sema::getSuperIdentifier() const {
2088 if (!Ident_super)
2089 Ident_super = &Context.Idents.get("super");
2090 return Ident_super;
2091}
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002092
Nico Webere1687c52013-06-20 21:44:55 +00002093IdentifierInfo *Sema::getFloat128Identifier() const {
2094 if (!Ident___float128)
2095 Ident___float128 = &Context.Idents.get("__float128");
2096 return Ident___float128;
2097}
2098
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002099void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
Ben Langmuire7d7c4c2013-04-29 13:32:41 +00002100 CapturedRegionKind K) {
Nico Weber63816332014-07-26 23:20:08 +00002101 CapturingScopeInfo *CSI = new CapturedRegionScopeInfo(
Alexey Bataev7ace49d2016-05-17 08:55:33 +00002102 getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
2103 (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0);
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002104 CSI->ReturnType = Context.VoidTy;
2105 FunctionScopes.push_back(CSI);
2106}
2107
2108CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
2109 if (FunctionScopes.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00002110 return nullptr;
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002111
2112 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
2113}
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00002114
2115const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
2116Sema::getMismatchingDeleteExpressions() const {
2117 return DeleteExprs;
2118}
Yaxun Liu5b746652016-12-18 05:18:55 +00002119
2120void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
2121 if (ExtStr.empty())
2122 return;
2123 llvm::SmallVector<StringRef, 1> Exts;
2124 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2125 auto CanT = T.getCanonicalType().getTypePtr();
2126 for (auto &I : Exts)
2127 OpenCLTypeExtMap[CanT].insert(I.str());
2128}
2129
2130void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
2131 llvm::SmallVector<StringRef, 1> Exts;
2132 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2133 if (Exts.empty())
2134 return;
2135 for (auto &I : Exts)
2136 OpenCLDeclExtMap[FD].insert(I.str());
2137}
2138
2139void Sema::setCurrentOpenCLExtensionForType(QualType T) {
2140 if (CurrOpenCLExtension.empty())
2141 return;
2142 setOpenCLExtensionForType(T, CurrOpenCLExtension);
2143}
2144
2145void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) {
2146 if (CurrOpenCLExtension.empty())
2147 return;
2148 setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
2149}
2150
Andrew Savonichev16f16992018-10-11 13:35:34 +00002151std::string Sema::getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD) {
2152 if (!OpenCLDeclExtMap.empty())
2153 return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
2154
2155 return "";
2156}
2157
2158std::string Sema::getOpenCLExtensionsFromTypeExtMap(FunctionType *FT) {
2159 if (!OpenCLTypeExtMap.empty())
2160 return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
2161
2162 return "";
2163}
2164
2165template <typename T, typename MapT>
2166std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
2167 std::string ExtensionNames = "";
2168 auto Loc = Map.find(FDT);
2169
2170 for (auto const& I : Loc->second) {
2171 ExtensionNames += I;
2172 ExtensionNames += " ";
2173 }
2174 ExtensionNames.pop_back();
2175
2176 return ExtensionNames;
2177}
2178
Yaxun Liu5b746652016-12-18 05:18:55 +00002179bool Sema::isOpenCLDisabledDecl(Decl *FD) {
2180 auto Loc = OpenCLDeclExtMap.find(FD);
2181 if (Loc == OpenCLDeclExtMap.end())
2182 return false;
2183 for (auto &I : Loc->second) {
2184 if (!getOpenCLOptions().isEnabled(I))
2185 return true;
2186 }
2187 return false;
2188}
2189
2190template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
2191bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
2192 DiagInfoT DiagInfo, MapT &Map,
2193 unsigned Selector,
2194 SourceRange SrcRange) {
2195 auto Loc = Map.find(D);
2196 if (Loc == Map.end())
2197 return false;
2198 bool Disabled = false;
2199 for (auto &I : Loc->second) {
2200 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
2201 Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
2202 << I << SrcRange;
2203 Disabled = true;
2204 }
2205 }
2206 return Disabled;
2207}
2208
2209bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) {
2210 // Check extensions for declared types.
2211 Decl *Decl = nullptr;
2212 if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
2213 Decl = TypedefT->getDecl();
2214 if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
2215 Decl = TagT->getDecl();
2216 auto Loc = DS.getTypeSpecTypeLoc();
Alexey Sotkin73ae7cb2018-09-03 11:43:22 +00002217
2218 // Check extensions for vector types.
2219 // e.g. double4 is not allowed when cl_khr_fp64 is absent.
2220 if (QT->isExtVectorType()) {
2221 auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
2222 return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
2223 }
2224
Yaxun Liu5b746652016-12-18 05:18:55 +00002225 if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
2226 return true;
2227
2228 // Check extensions for builtin types.
2229 return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2230 QT, OpenCLTypeExtMap);
2231}
2232
Joey Gouly186791d2017-06-30 14:23:01 +00002233bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
2234 IdentifierInfo *FnName = D.getIdentifier();
Stephen Kellyf2ceec42018-08-09 21:08:08 +00002235 return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
Yaxun Liu5b746652016-12-18 05:18:55 +00002236 OpenCLDeclExtMap, 1, D.getSourceRange());
2237}