blob: c3c6cad277ff7843690f1fe095417da0fd861fe7 [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"
Richard Smith26a92d52019-08-26 18:18:07 +000025#include "clang/Basic/Stack.h"
Chris Lattner7d4f5c42009-04-30 06:18:40 +000026#include "clang/Basic/TargetInfo.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000027#include "clang/Lex/HeaderSearch.h"
28#include "clang/Lex/Preprocessor.h"
29#include "clang/Sema/CXXFieldCollector.h"
30#include "clang/Sema/DelayedDiagnostic.h"
31#include "clang/Sema/ExternalSemaSource.h"
Richard Smith7873de02016-08-11 22:25:46 +000032#include "clang/Sema/Initialization.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000033#include "clang/Sema/MultiplexExternalSemaSource.h"
34#include "clang/Sema/ObjCMethodList.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000035#include "clang/Sema/Scope.h"
36#include "clang/Sema/ScopeInfo.h"
37#include "clang/Sema/SemaConsumer.h"
Mehdi Amini9670f842016-07-18 19:02:11 +000038#include "clang/Sema/SemaInternal.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000039#include "clang/Sema/TemplateDeduction.h"
Gabor Horvath207e7b12018-02-10 14:04:45 +000040#include "clang/Sema/TemplateInstCallback.h"
Ilya Biryukovaeae71c2019-10-09 10:00:05 +000041#include "clang/Sema/TypoCorrection.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000042#include "llvm/ADT/DenseMap.h"
43#include "llvm/ADT/SmallSet.h"
Anton Afanasyevd880de22019-03-30 08:42:48 +000044#include "llvm/Support/TimeProfiler.h"
45
Chris Lattnerc11438c2006-08-18 05:17:52 +000046using namespace clang;
John McCallaab3e412010-08-25 08:40:02 +000047using namespace sema;
Douglas Gregor9a28e842010-03-01 23:15:13 +000048
Alp Tokerb6cc5922014-05-03 03:45:55 +000049SourceLocation Sema::getLocForEndOfToken(SourceLocation Loc, unsigned Offset) {
50 return Lexer::getLocForEndOfToken(Loc, Offset, SourceMgr, LangOpts);
51}
52
53ModuleLoader &Sema::getModuleLoader() const { return PP.getModuleLoader(); }
54
Argyrios Kyrtzidis8d05ca72012-01-17 02:15:51 +000055PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
56 const Preprocessor &PP) {
Douglas Gregor75acd922011-09-27 23:30:47 +000057 PrintingPolicy Policy = Context.getPrintingPolicy();
Joel E. Denny7bcc2102018-05-14 18:41:44 +000058 // In diagnostics, we print _Bool as bool if the latter is defined as the
59 // former.
David Blaikiebbafb8a2012-03-11 07:00:24 +000060 Policy.Bool = Context.getLangOpts().Bool;
Douglas Gregor75acd922011-09-27 23:30:47 +000061 if (!Policy.Bool) {
Richard Smith301bc212016-05-19 01:39:10 +000062 if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
Michael Gottesmanbf0fd392013-01-20 01:04:14 +000063 Policy.Bool = BoolMacro->isObjectLike() &&
Richard Smith301bc212016-05-19 01:39:10 +000064 BoolMacro->getNumTokens() == 1 &&
65 BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
Douglas Gregor75acd922011-09-27 23:30:47 +000066 }
67 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +000068
Douglas Gregor75acd922011-09-27 23:30:47 +000069 return Policy;
70}
71
Douglas Gregorf11096c2010-08-25 18:07:12 +000072void Sema::ActOnTranslationUnitScope(Scope *S) {
Steve Naroffc62adb62007-10-09 22:01:59 +000073 TUScope = S;
Douglas Gregor91f84212008-12-11 16:49:14 +000074 PushDeclContext(S, Context.getTranslationUnitDecl());
Steve Naroff7f549f12007-10-10 21:53:07 +000075}
76
Alex Lorenz45b40142017-07-28 14:41:21 +000077namespace clang {
78namespace sema {
79
80class SemaPPCallbacks : public PPCallbacks {
81 Sema *S = nullptr;
82 llvm::SmallVector<SourceLocation, 8> IncludeStack;
83
84public:
85 void set(Sema &S) { this->S = &S; }
86
87 void reset() { S = nullptr; }
88
89 virtual void FileChanged(SourceLocation Loc, FileChangeReason Reason,
90 SrcMgr::CharacteristicKind FileType,
91 FileID PrevFID) override {
92 if (!S)
93 return;
94 switch (Reason) {
95 case EnterFile: {
96 SourceManager &SM = S->getSourceManager();
97 SourceLocation IncludeLoc = SM.getIncludeLoc(SM.getFileID(Loc));
98 if (IncludeLoc.isValid()) {
Anton Afanasyevd880de22019-03-30 08:42:48 +000099 if (llvm::timeTraceProfilerEnabled()) {
100 const FileEntry *FE = SM.getFileEntryForID(SM.getFileID(Loc));
101 llvm::timeTraceProfilerBegin(
102 "Source", FE != nullptr ? FE->getName() : StringRef("<unknown>"));
103 }
104
Alex Lorenz45b40142017-07-28 14:41:21 +0000105 IncludeStack.push_back(IncludeLoc);
106 S->DiagnoseNonDefaultPragmaPack(
107 Sema::PragmaPackDiagnoseKind::NonDefaultStateAtInclude, IncludeLoc);
108 }
109 break;
110 }
111 case ExitFile:
Anton Afanasyevd880de22019-03-30 08:42:48 +0000112 if (!IncludeStack.empty()) {
113 if (llvm::timeTraceProfilerEnabled())
114 llvm::timeTraceProfilerEnd();
115
Alex Lorenz45b40142017-07-28 14:41:21 +0000116 S->DiagnoseNonDefaultPragmaPack(
117 Sema::PragmaPackDiagnoseKind::ChangedStateAtExit,
118 IncludeStack.pop_back_val());
Anton Afanasyevd880de22019-03-30 08:42:48 +0000119 }
Alex Lorenz45b40142017-07-28 14:41:21 +0000120 break;
121 default:
122 break;
123 }
124 }
125};
126
127} // end namespace sema
128} // end namespace clang
129
Douglas Gregor54feb842009-04-14 16:27:31 +0000130Sema::Sema(Preprocessor &pp, ASTContext &ctxt, ASTConsumer &consumer,
Alex Lorenz9e7bf162017-04-18 14:33:39 +0000131 TranslationUnitKind TUKind, CodeCompleteConsumer *CodeCompleter)
132 : ExternalSource(nullptr), isMultiplexExternalSource(false),
133 FPFeatures(pp.getLangOpts()), LangOpts(pp.getLangOpts()), PP(pp),
134 Context(ctxt), Consumer(consumer), Diags(PP.getDiagnostics()),
135 SourceMgr(PP.getSourceManager()), CollectStats(false),
136 CodeCompleter(CodeCompleter), CurContext(nullptr),
137 OriginalLexicalContext(nullptr), MSStructPragmaOn(false),
138 MSPointerToMemberRepresentationMethod(
139 LangOpts.getMSPointerToMemberRepresentationMethod()),
140 VtorDispStack(MSVtorDispAttr::Mode(LangOpts.VtorDispMode)), PackStack(0),
141 DataSegStack(nullptr), BSSSegStack(nullptr), ConstSegStack(nullptr),
142 CodeSegStack(nullptr), CurInitSeg(nullptr), VisContext(nullptr),
143 PragmaAttributeCurrentTargetDecl(nullptr),
144 IsBuildingRecoveryCallExpr(false), Cleanup{}, LateTemplateParser(nullptr),
145 LateTemplateParserCleanup(nullptr), OpaqueParser(nullptr), IdResolver(pp),
146 StdExperimentalNamespaceCache(nullptr), StdInitializerList(nullptr),
Brian Gesiak3e65d9a2018-07-14 18:21:44 +0000147 StdCoroutineTraitsCache(nullptr), CXXTypeInfoDecl(nullptr),
148 MSVCGuidDecl(nullptr), NSNumberDecl(nullptr), NSValueDecl(nullptr),
149 NSStringDecl(nullptr), StringWithUTF8StringMethod(nullptr),
Alex Lorenz9e7bf162017-04-18 14:33:39 +0000150 ValueWithBytesObjCTypeMethod(nullptr), NSArrayDecl(nullptr),
151 ArrayWithObjectsMethod(nullptr), NSDictionaryDecl(nullptr),
152 DictionaryWithObjectsMethod(nullptr), GlobalNewDeleteDeclared(false),
Eric Fiselier0683c0e2018-05-07 21:07:10 +0000153 TUKind(TUKind), NumSFINAEErrors(0),
154 FullyCheckedComparisonCategories(
155 static_cast<unsigned>(ComparisonCategoryType::Last) + 1),
156 AccessCheckingSFINAE(false), InNonInstantiationSFINAEContext(false),
157 NonInstantiationEntries(0), ArgumentPackSubstitutionIndex(-1),
158 CurrentInstantiationScope(nullptr), DisableTypoCorrection(false),
159 TyposCorrected(0), AnalysisWarnings(*this),
Alex Lorenz9e7bf162017-04-18 14:33:39 +0000160 ThreadSafetyDeclCache(nullptr), VarDataSharingAttributesStack(nullptr),
161 CurScope(nullptr), Ident_super(nullptr), Ident___float128(nullptr) {
Craig Topperc3ec1492014-05-26 06:22:03 +0000162 TUScope = nullptr;
Gauthier Harnisch0bb4d462019-06-15 08:32:56 +0000163 isConstantEvaluatedOverride = false;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000164
Douglas Gregorc2fa1692011-06-28 16:20:02 +0000165 LoadedExternalKnownNamespaces = false;
Ted Kremeneke65b0862012-03-06 20:05:56 +0000166 for (unsigned I = 0; I != NSAPI::NumNSNumberLiteralMethods; ++I)
Craig Topperc3ec1492014-05-26 06:22:03 +0000167 NSNumberLiteralMethods[I] = nullptr;
Ted Kremeneke65b0862012-03-06 20:05:56 +0000168
Erik Pilkingtonfa983902018-10-30 20:31:30 +0000169 if (getLangOpts().ObjC)
Ted Kremeneke65b0862012-03-06 20:05:56 +0000170 NSAPIObj.reset(new NSAPI(Context));
171
David Blaikiebbafb8a2012-03-11 07:00:24 +0000172 if (getLangOpts().CPlusPlus)
Argyrios Kyrtzidised983422008-07-01 10:37:29 +0000173 FieldCollector.reset(new CXXFieldCollector());
Mike Stump11289f42009-09-09 15:08:12 +0000174
Chris Lattner6a2ed6f2008-11-23 09:13:29 +0000175 // Tell diagnostics how to render things from the AST library.
Craig Topper12126262015-11-15 17:27:57 +0000176 Diags.SetArgToStringFn(&FormatASTNodeDiagnosticArgument, &Context);
Douglas Gregorff790f12009-11-26 00:44:06 +0000177
Faisal Valid143a0c2017-04-01 21:30:49 +0000178 ExprEvalContexts.emplace_back(
179 ExpressionEvaluationContext::PotentiallyEvaluated, 0, CleanupInfo{},
Nicolas Lesserb6d5c582018-07-12 18:45:41 +0000180 nullptr, ExpressionEvaluationContextRecord::EK_Other);
John McCallaab3e412010-08-25 08:40:02 +0000181
Raphael Isemannb23ccec2018-12-10 12:37:46 +0000182 // Initialization of data sharing attributes stack for OpenMP
Alexey Bataev758e55e2013-09-06 18:03:48 +0000183 InitDataSharingAttributesStack();
Alex Lorenz45b40142017-07-28 14:41:21 +0000184
185 std::unique_ptr<sema::SemaPPCallbacks> Callbacks =
Jonas Devlieghere2b3d49b2019-08-14 23:04:18 +0000186 std::make_unique<sema::SemaPPCallbacks>();
Alex Lorenz45b40142017-07-28 14:41:21 +0000187 SemaPPCallbackHandler = Callbacks.get();
188 PP.addPPCallbacks(std::move(Callbacks));
189 SemaPPCallbackHandler->set(*this);
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000190}
191
Reid Kleckner586f65d2019-11-15 11:22:02 -0800192// Anchor Sema's type info to this TU.
193void Sema::anchor() {}
194
Alp Tokerf22856a2013-12-18 15:29:05 +0000195void Sema::addImplicitTypedef(StringRef Name, QualType T) {
196 DeclarationName DN = &Context.Idents.get(Name);
197 if (IdResolver.begin(DN) == IdResolver.end())
198 PushOnScopeChains(Context.buildImplicitTypedef(T, Name), TUScope);
199}
200
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000201void Sema::Initialize() {
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000202 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
203 SC->InitializeSema(*this);
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000204
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000205 // Tell the external Sema source about this Sema object.
206 if (ExternalSemaSource *ExternalSema
207 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
208 ExternalSema->InitializeSema(*this);
Douglas Gregor3ea72692011-08-12 05:46:01 +0000209
Ben Langmuirbb1c9182014-09-05 20:24:27 +0000210 // This needs to happen after ExternalSemaSource::InitializeSema(this) or we
211 // will not be able to merge any duplicate __va_list_tag decls correctly.
212 VAListTagName = PP.getIdentifierInfo("__va_list_tag");
213
Richard Smith33e0f7e2015-07-22 02:08:40 +0000214 if (!TUScope)
215 return;
216
Douglas Gregor801c99d2011-08-12 06:49:56 +0000217 // Initialize predefined 128-bit integer types, if needed.
Alp Tokerb6cc5922014-05-03 03:45:55 +0000218 if (Context.getTargetInfo().hasInt128Type()) {
Douglas Gregor801c99d2011-08-12 06:49:56 +0000219 // If either of the 128-bit integer types are unavailable to name lookup,
220 // define them now.
221 DeclarationName Int128 = &Context.Idents.get("__int128_t");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000222 if (IdResolver.begin(Int128) == IdResolver.end())
Douglas Gregor801c99d2011-08-12 06:49:56 +0000223 PushOnScopeChains(Context.getInt128Decl(), TUScope);
224
225 DeclarationName UInt128 = &Context.Idents.get("__uint128_t");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000226 if (IdResolver.begin(UInt128) == IdResolver.end())
Douglas Gregor801c99d2011-08-12 06:49:56 +0000227 PushOnScopeChains(Context.getUInt128Decl(), TUScope);
228 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000229
Douglas Gregor801c99d2011-08-12 06:49:56 +0000230
Douglas Gregor3ea72692011-08-12 05:46:01 +0000231 // Initialize predefined Objective-C types:
Erik Pilkingtonfa983902018-10-30 20:31:30 +0000232 if (getLangOpts().ObjC) {
Douglas Gregor52e02802011-08-12 06:17:30 +0000233 // If 'SEL' does not yet refer to any declarations, make it refer to the
234 // predefined 'SEL'.
235 DeclarationName SEL = &Context.Idents.get("SEL");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000236 if (IdResolver.begin(SEL) == IdResolver.end())
Douglas Gregor52e02802011-08-12 06:17:30 +0000237 PushOnScopeChains(Context.getObjCSelDecl(), TUScope);
238
Douglas Gregor3ea72692011-08-12 05:46:01 +0000239 // If 'id' does not yet refer to any declarations, make it refer to the
240 // predefined 'id'.
241 DeclarationName Id = &Context.Idents.get("id");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000242 if (IdResolver.begin(Id) == IdResolver.end())
Douglas Gregor3ea72692011-08-12 05:46:01 +0000243 PushOnScopeChains(Context.getObjCIdDecl(), TUScope);
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000244
Douglas Gregor0a586182011-08-12 05:59:41 +0000245 // Create the built-in typedef for 'Class'.
246 DeclarationName Class = &Context.Idents.get("Class");
Douglas Gregor935bc7a22011-10-27 09:33:13 +0000247 if (IdResolver.begin(Class) == IdResolver.end())
Douglas Gregor0a586182011-08-12 05:59:41 +0000248 PushOnScopeChains(Context.getObjCClassDecl(), TUScope);
Douglas Gregord53ae832012-01-17 18:09:05 +0000249
250 // Create the built-in forward declaratino for 'Protocol'.
251 DeclarationName Protocol = &Context.Idents.get("Protocol");
252 if (IdResolver.begin(Protocol) == IdResolver.end())
253 PushOnScopeChains(Context.getObjCProtocolDecl(), TUScope);
Douglas Gregor3ea72692011-08-12 05:46:01 +0000254 }
Meador Inge5d3fb222012-06-16 03:34:49 +0000255
Ben Langmuirf5416742016-02-04 00:55:24 +0000256 // Create the internal type for the *StringMakeConstantString builtins.
257 DeclarationName ConstantString = &Context.Idents.get("__NSConstantString");
258 if (IdResolver.begin(ConstantString) == IdResolver.end())
259 PushOnScopeChains(Context.getCFConstantStringDecl(), TUScope);
260
Alp Tokere1fab522014-01-04 15:25:02 +0000261 // Initialize Microsoft "predefined C++ types".
Craig Topper12126262015-11-15 17:27:57 +0000262 if (getLangOpts().MSVCCompat) {
263 if (getLangOpts().CPlusPlus &&
David Majnemerbe525392015-02-18 02:28:13 +0000264 IdResolver.begin(&Context.Idents.get("type_info")) == IdResolver.end())
Alp Tokere1fab522014-01-04 15:25:02 +0000265 PushOnScopeChains(Context.buildImplicitRecord("type_info", TTK_Class),
266 TUScope);
David Majnemer1de36912014-01-14 06:19:35 +0000267
268 addImplicitTypedef("size_t", Context.getSizeType());
Alp Tokere1fab522014-01-04 15:25:02 +0000269 }
270
Yaxun Liu5b746652016-12-18 05:18:55 +0000271 // Initialize predefined OpenCL types and supported extensions and (optional)
272 // core features.
Craig Topper12126262015-11-15 17:27:57 +0000273 if (getLangOpts().OpenCL) {
Anastasia Stulovae88e2b92019-02-07 17:32:37 +0000274 getOpenCLOptions().addSupport(
275 Context.getTargetInfo().getSupportedOpenCLOpts());
276 getOpenCLOptions().enableSupportedCore(getLangOpts());
Alp Tokerf22856a2013-12-18 15:29:05 +0000277 addImplicitTypedef("sampler_t", Context.OCLSamplerTy);
278 addImplicitTypedef("event_t", Context.OCLEventTy);
Anastasia Stulovae88e2b92019-02-07 17:32:37 +0000279 if (getLangOpts().OpenCLCPlusPlus || getLangOpts().OpenCLVersion >= 200) {
Alexey Bader9c8453f2015-09-15 11:18:52 +0000280 addImplicitTypedef("clk_event_t", Context.OCLClkEventTy);
281 addImplicitTypedef("queue_t", Context.OCLQueueTy);
Alexey Bader9c8453f2015-09-15 11:18:52 +0000282 addImplicitTypedef("reserve_id_t", Context.OCLReserveIDTy);
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000283 addImplicitTypedef("atomic_int", Context.getAtomicType(Context.IntTy));
284 addImplicitTypedef("atomic_uint",
285 Context.getAtomicType(Context.UnsignedIntTy));
Yaxun Liu5b746652016-12-18 05:18:55 +0000286 auto AtomicLongT = Context.getAtomicType(Context.LongTy);
287 addImplicitTypedef("atomic_long", AtomicLongT);
288 auto AtomicULongT = Context.getAtomicType(Context.UnsignedLongTy);
289 addImplicitTypedef("atomic_ulong", AtomicULongT);
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000290 addImplicitTypedef("atomic_float",
291 Context.getAtomicType(Context.FloatTy));
Yaxun Liu5b746652016-12-18 05:18:55 +0000292 auto AtomicDoubleT = Context.getAtomicType(Context.DoubleTy);
293 addImplicitTypedef("atomic_double", AtomicDoubleT);
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000294 // OpenCLC v2.0, s6.13.11.6 requires that atomic_flag is implemented as
295 // 32-bit integer and OpenCLC v2.0, s6.1.1 int is always 32-bit wide.
296 addImplicitTypedef("atomic_flag", Context.getAtomicType(Context.IntTy));
Yaxun Liu5b746652016-12-18 05:18:55 +0000297 auto AtomicIntPtrT = Context.getAtomicType(Context.getIntPtrType());
298 addImplicitTypedef("atomic_intptr_t", AtomicIntPtrT);
299 auto AtomicUIntPtrT = Context.getAtomicType(Context.getUIntPtrType());
300 addImplicitTypedef("atomic_uintptr_t", AtomicUIntPtrT);
301 auto AtomicSizeT = Context.getAtomicType(Context.getSizeType());
302 addImplicitTypedef("atomic_size_t", AtomicSizeT);
303 auto AtomicPtrDiffT = Context.getAtomicType(Context.getPointerDiffType());
304 addImplicitTypedef("atomic_ptrdiff_t", AtomicPtrDiffT);
305
306 // OpenCL v2.0 s6.13.11.6:
307 // - The atomic_long and atomic_ulong types are supported if the
308 // cl_khr_int64_base_atomics and cl_khr_int64_extended_atomics
309 // extensions are supported.
310 // - The atomic_double type is only supported if double precision
311 // is supported and the cl_khr_int64_base_atomics and
312 // cl_khr_int64_extended_atomics extensions are supported.
313 // - If the device address space is 64-bits, the data types
314 // atomic_intptr_t, atomic_uintptr_t, atomic_size_t and
315 // atomic_ptrdiff_t are supported if the cl_khr_int64_base_atomics and
316 // cl_khr_int64_extended_atomics extensions are supported.
317 std::vector<QualType> Atomic64BitTypes;
318 Atomic64BitTypes.push_back(AtomicLongT);
319 Atomic64BitTypes.push_back(AtomicULongT);
320 Atomic64BitTypes.push_back(AtomicDoubleT);
321 if (Context.getTypeSize(AtomicSizeT) == 64) {
322 Atomic64BitTypes.push_back(AtomicSizeT);
323 Atomic64BitTypes.push_back(AtomicIntPtrT);
324 Atomic64BitTypes.push_back(AtomicUIntPtrT);
325 Atomic64BitTypes.push_back(AtomicPtrDiffT);
326 }
327 for (auto &I : Atomic64BitTypes)
328 setOpenCLExtensionForType(I,
329 "cl_khr_int64_base_atomics cl_khr_int64_extended_atomics");
330
331 setOpenCLExtensionForType(AtomicDoubleT, "cl_khr_fp64");
Anastasia Stulovab1152f12015-03-18 12:55:29 +0000332 }
Yaxun Liu5b746652016-12-18 05:18:55 +0000333
334 setOpenCLExtensionForType(Context.DoubleTy, "cl_khr_fp64");
335
336#define GENERIC_IMAGE_TYPE_EXT(Type, Id, Ext) \
337 setOpenCLExtensionForType(Context.Id, Ext);
338#include "clang/Basic/OpenCLImageTypes.def"
Andrew Savonichev3fee3512018-11-08 11:25:41 +0000339#define EXT_OPAQUE_TYPE(ExtType, Id, Ext) \
340 addImplicitTypedef(#ExtType, Context.Id##Ty); \
341 setOpenCLExtensionForType(Context.Id##Ty, #Ext);
342#include "clang/Basic/OpenCLExtensionTypes.def"
Richard Sandifordeb485fb2019-08-09 08:52:54 +0000343 }
344
345 if (Context.getTargetInfo().hasAArch64SVETypes()) {
346#define SVE_TYPE(Name, Id, SingletonId) \
347 addImplicitTypedef(Name, Context.SingletonId);
348#include "clang/Basic/AArch64SVEACLETypes.def"
349 }
Alp Tokerf22856a2013-12-18 15:29:05 +0000350
Craig Topper12126262015-11-15 17:27:57 +0000351 if (Context.getTargetInfo().hasBuiltinMSVaList()) {
Charles Davisc7d5c942015-09-17 20:55:33 +0000352 DeclarationName MSVaList = &Context.Idents.get("__builtin_ms_va_list");
353 if (IdResolver.begin(MSVaList) == IdResolver.end())
354 PushOnScopeChains(Context.getBuiltinMSVaListDecl(), TUScope);
355 }
356
Meador Inge5d3fb222012-06-16 03:34:49 +0000357 DeclarationName BuiltinVaList = &Context.Idents.get("__builtin_va_list");
358 if (IdResolver.begin(BuiltinVaList) == IdResolver.end())
359 PushOnScopeChains(Context.getBuiltinVaListDecl(), TUScope);
Steve Naroff38d31b42007-02-28 01:22:02 +0000360}
Chris Lattnercb6a3822006-11-10 06:20:45 +0000361
Anton Korobeynikov55bcea12010-01-10 12:58:08 +0000362Sema::~Sema() {
Eli Friedman570024a2010-08-05 06:57:20 +0000363 if (VisContext) FreeVisContext();
Reid Kleckner87a31802018-03-12 21:43:02 +0000364
John McCallaab3e412010-08-25 08:40:02 +0000365 // Kill all the active scopes.
Reid Kleckner87a31802018-03-12 21:43:02 +0000366 for (sema::FunctionScopeInfo *FSI : FunctionScopes)
Richard Smith2fdd95c2019-05-31 00:45:09 +0000367 delete FSI;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000368
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000369 // Tell the SemaConsumer to forget about us; we're going out of scope.
370 if (SemaConsumer *SC = dyn_cast<SemaConsumer>(&Consumer))
371 SC->ForgetSema();
372
373 // Detach from the external Sema source.
374 if (ExternalSemaSource *ExternalSema
Douglas Gregor6fd55e02010-08-13 03:15:25 +0000375 = dyn_cast_or_null<ExternalSemaSource>(Context.getExternalSource()))
Douglas Gregor5c6f10b2010-08-12 22:51:45 +0000376 ExternalSema->ForgetSema();
Axel Naumanndd433f02012-10-18 19:05:02 +0000377
378 // If Sema's ExternalSource is the multiplexer - we own it.
379 if (isMultiplexExternalSource)
380 delete ExternalSource;
Alexey Bataev758e55e2013-09-06 18:03:48 +0000381
DeLesley Hutchinsab1dc2d2015-02-03 22:11:04 +0000382 threadSafety::threadSafetyCleanup(ThreadSafetyDeclCache);
383
Alexey Bataev758e55e2013-09-06 18:03:48 +0000384 // Destroys data sharing attributes stack for OpenMP
385 DestroyDataSharingAttributesStack();
Kaelyn Takataef3e42b2014-11-21 18:48:06 +0000386
Alex Lorenz45b40142017-07-28 14:41:21 +0000387 // Detach from the PP callback handler which outlives Sema since it's owned
388 // by the preprocessor.
389 SemaPPCallbackHandler->reset();
Anton Korobeynikov55bcea12010-01-10 12:58:08 +0000390}
391
Richard Smith26a92d52019-08-26 18:18:07 +0000392void Sema::warnStackExhausted(SourceLocation Loc) {
393 // Only warn about this once.
394 if (!WarnedStackExhausted) {
395 Diag(Loc, diag::warn_stack_exhausted);
396 WarnedStackExhausted = true;
397 }
398}
399
400void Sema::runWithSufficientStackSpace(SourceLocation Loc,
401 llvm::function_ref<void()> Fn) {
402 clang::runWithSufficientStackSpace([&] { warnStackExhausted(Loc); }, Fn);
403}
404
John McCall31168b02011-06-15 23:02:42 +0000405/// makeUnavailableInSystemHeader - There is an error in the current
406/// context. If we're still in a system header, and we can plausibly
407/// make the relevant declaration unavailable instead of erroring, do
408/// so and return true.
409bool Sema::makeUnavailableInSystemHeader(SourceLocation loc,
John McCallc6af8c62015-10-28 05:03:19 +0000410 UnavailableAttr::ImplicitReason reason) {
John McCall31168b02011-06-15 23:02:42 +0000411 // If we're not in a function, it's an error.
412 FunctionDecl *fn = dyn_cast<FunctionDecl>(CurContext);
413 if (!fn) return false;
414
415 // If we're in template instantiation, it's an error.
Richard Smith51ec0cf2017-02-21 01:17:38 +0000416 if (inTemplateInstantiation())
John McCall31168b02011-06-15 23:02:42 +0000417 return false;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000418
John McCall31168b02011-06-15 23:02:42 +0000419 // If that function's not in a system header, it's an error.
420 if (!Context.getSourceManager().isInSystemHeader(loc))
421 return false;
422
423 // If the function is already unavailable, it's not an error.
424 if (fn->hasAttr<UnavailableAttr>()) return true;
425
John McCallc6af8c62015-10-28 05:03:19 +0000426 fn->addAttr(UnavailableAttr::CreateImplicit(Context, "", reason, loc));
John McCall31168b02011-06-15 23:02:42 +0000427 return true;
428}
429
Sebastian Redlab238a72011-04-24 16:28:06 +0000430ASTMutationListener *Sema::getASTMutationListener() const {
431 return getASTConsumer().GetASTMutationListener();
432}
433
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000434///Registers an external source. If an external source already exists,
Axel Naumanndd433f02012-10-18 19:05:02 +0000435/// creates a multiplex external source and appends to it.
436///
437///\param[in] E - A non-null external sema source.
438///
439void Sema::addExternalSource(ExternalSemaSource *E) {
440 assert(E && "Cannot use with NULL ptr");
441
442 if (!ExternalSource) {
443 ExternalSource = E;
444 return;
445 }
446
447 if (isMultiplexExternalSource)
448 static_cast<MultiplexExternalSemaSource*>(ExternalSource)->addSource(*E);
449 else {
450 ExternalSource = new MultiplexExternalSemaSource(*ExternalSource, *E);
451 isMultiplexExternalSource = true;
452 }
453}
454
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000455/// Print out statistics about the semantic analysis.
Chandler Carruthb4836ea2011-07-06 16:21:37 +0000456void Sema::PrintStats() const {
457 llvm::errs() << "\n*** Semantic Analysis Stats:\n";
458 llvm::errs() << NumSFINAEErrors << " SFINAE diagnostics trapped.\n";
459
460 BumpAlloc.PrintStats();
461 AnalysisWarnings.PrintStats();
462}
463
George Burgess IV8d141e02015-12-14 22:00:49 +0000464void Sema::diagnoseNullableToNonnullConversion(QualType DstType,
465 QualType SrcType,
466 SourceLocation Loc) {
467 Optional<NullabilityKind> ExprNullability = SrcType->getNullability(Context);
468 if (!ExprNullability || *ExprNullability != NullabilityKind::Nullable)
469 return;
470
471 Optional<NullabilityKind> TypeNullability = DstType->getNullability(Context);
472 if (!TypeNullability || *TypeNullability != NullabilityKind::NonNull)
473 return;
474
475 Diag(Loc, diag::warn_nullability_lost) << SrcType << DstType;
476}
477
Nico Weberd7ba86b2017-05-05 16:11:08 +0000478void Sema::diagnoseZeroToNullptrConversion(CastKind Kind, const Expr* E) {
Roman Lebedev809df342017-10-26 13:18:14 +0000479 if (Diags.isIgnored(diag::warn_zero_as_null_pointer_constant,
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000480 E->getBeginLoc()))
Roman Lebedev809df342017-10-26 13:18:14 +0000481 return;
482 // nullptr only exists from C++11 on, so don't warn on its absence earlier.
483 if (!getLangOpts().CPlusPlus11)
484 return;
485
Nico Weberd7ba86b2017-05-05 16:11:08 +0000486 if (Kind != CK_NullToPointer && Kind != CK_NullToMemberPointer)
487 return;
Erich Keane818cf5b2017-10-25 20:23:13 +0000488 if (E->IgnoreParenImpCasts()->getType()->isNullPtrType())
Nico Weberd7ba86b2017-05-05 16:11:08 +0000489 return;
Roman Lebedev809df342017-10-26 13:18:14 +0000490
491 // If it is a macro from system header, and if the macro name is not "NULL",
492 // do not warn.
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000493 SourceLocation MaybeMacroLoc = E->getBeginLoc();
Roman Lebedev809df342017-10-26 13:18:14 +0000494 if (Diags.getSuppressSystemWarnings() &&
495 SourceMgr.isInSystemMacro(MaybeMacroLoc) &&
496 !findMacroSpelling(MaybeMacroLoc, "NULL"))
Nico Weberd7ba86b2017-05-05 16:11:08 +0000497 return;
498
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000499 Diag(E->getBeginLoc(), diag::warn_zero_as_null_pointer_constant)
Nico Weberd7ba86b2017-05-05 16:11:08 +0000500 << FixItHint::CreateReplacement(E->getSourceRange(), "nullptr");
501}
502
Richard Smith507840d2011-11-29 22:48:16 +0000503/// ImpCastExprToType - If Expr is not of type 'Type', insert an implicit cast.
504/// If there is already an implicit cast, merge into the existing one.
505/// The result is of the given category.
506ExprResult Sema::ImpCastExprToType(Expr *E, QualType Ty,
507 CastKind Kind, ExprValueKind VK,
508 const CXXCastPath *BasePath,
509 CheckedConversionKind CCK) {
Richard Smith508ebf32011-10-28 03:31:48 +0000510#ifndef NDEBUG
511 if (VK == VK_RValue && !E->isRValue()) {
512 switch (Kind) {
513 default:
Craig Topperd8d43192014-06-18 05:13:13 +0000514 llvm_unreachable("can't implicitly cast lvalue to rvalue with this cast "
515 "kind");
Richard Smith07ed9cf2019-06-20 19:49:13 +0000516 case CK_Dependent:
Richard Smith508ebf32011-10-28 03:31:48 +0000517 case CK_LValueToRValue:
518 case CK_ArrayToPointerDecay:
519 case CK_FunctionToPointerDecay:
520 case CK_ToVoid:
JF Bastien7d60a0f2018-07-18 18:01:41 +0000521 case CK_NonAtomicToAtomic:
Richard Smith508ebf32011-10-28 03:31:48 +0000522 break;
523 }
524 }
Richard Smith07ed9cf2019-06-20 19:49:13 +0000525 assert((VK == VK_RValue || Kind == CK_Dependent || !E->isRValue()) &&
526 "can't cast rvalue to lvalue");
Richard Smith508ebf32011-10-28 03:31:48 +0000527#endif
528
Stephen Kellyf2ceec42018-08-09 21:08:08 +0000529 diagnoseNullableToNonnullConversion(Ty, E->getType(), E->getBeginLoc());
Nico Weberd7ba86b2017-05-05 16:11:08 +0000530 diagnoseZeroToNullptrConversion(Kind, E);
Douglas Gregorb4866e82015-06-19 18:13:19 +0000531
John Wiegley01296292011-04-08 18:41:53 +0000532 QualType ExprTy = Context.getCanonicalType(E->getType());
Mon P Wang74b32072008-09-04 08:38:01 +0000533 QualType TypeTy = Context.getCanonicalType(Ty);
Mike Stump11289f42009-09-09 15:08:12 +0000534
Mon P Wang74b32072008-09-04 08:38:01 +0000535 if (ExprTy == TypeTy)
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000536 return E;
Mike Stump11289f42009-09-09 15:08:12 +0000537
Richard Smithb3189a12016-12-05 07:49:14 +0000538 // C++1z [conv.array]: The temporary materialization conversion is applied.
539 // We also use this to fuel C++ DR1213, which applies to C++11 onwards.
540 if (Kind == CK_ArrayToPointerDecay && getLangOpts().CPlusPlus &&
541 E->getValueKind() == VK_RValue) {
542 // The temporary is an lvalue in C++98 and an xvalue otherwise.
543 ExprResult Materialized = CreateMaterializeTemporaryExpr(
544 E->getType(), E, !getLangOpts().CPlusPlus11);
545 if (Materialized.isInvalid())
546 return ExprError();
547 E = Materialized.get();
548 }
549
Richard Smith507840d2011-11-29 22:48:16 +0000550 if (ImplicitCastExpr *ImpCast = dyn_cast<ImplicitCastExpr>(E)) {
551 if (ImpCast->getCastKind() == Kind && (!BasePath || BasePath->empty())) {
552 ImpCast->setType(Ty);
553 ImpCast->setValueKind(VK);
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000554 return E;
Richard Smith507840d2011-11-29 22:48:16 +0000555 }
556 }
557
Nikola Smiljanic03ff2592014-05-29 14:05:12 +0000558 return ImplicitCastExpr::Create(Context, Ty, Kind, E, BasePath, VK);
Sebastian Redlc57d34b2010-07-20 04:20:21 +0000559}
560
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000561/// ScalarTypeToBooleanCastKind - Returns the cast kind corresponding
562/// to the conversion from scalar type ScalarTy to the Boolean type.
563CastKind Sema::ScalarTypeToBooleanCastKind(QualType ScalarTy) {
564 switch (ScalarTy->getScalarTypeKind()) {
565 case Type::STK_Bool: return CK_NoOp;
John McCall9320b872011-09-09 05:25:32 +0000566 case Type::STK_CPointer: return CK_PointerToBoolean;
567 case Type::STK_BlockPointer: return CK_PointerToBoolean;
568 case Type::STK_ObjCObjectPointer: return CK_PointerToBoolean;
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000569 case Type::STK_MemberPointer: return CK_MemberPointerToBoolean;
570 case Type::STK_Integral: return CK_IntegralToBoolean;
571 case Type::STK_Floating: return CK_FloatingToBoolean;
572 case Type::STK_IntegralComplex: return CK_IntegralComplexToBoolean;
573 case Type::STK_FloatingComplex: return CK_FloatingComplexToBoolean;
Leonard Chanb4ba4672018-10-23 17:55:35 +0000574 case Type::STK_FixedPoint: return CK_FixedPointToBoolean;
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000575 }
Richard Smith354abec2017-12-08 23:29:59 +0000576 llvm_unreachable("unknown scalar type kind");
Abramo Bagnara7ccce982011-04-07 09:26:19 +0000577}
578
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000579/// Used to prune the decls of Sema's UnusedFileScopedDecls vector.
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000580static bool ShouldRemoveFromUnused(Sema *SemaRef, const DeclaratorDecl *D) {
Rafael Espindola820fa702013-01-08 19:43:34 +0000581 if (D->getMostRecentDecl()->isUsed())
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000582 return true;
583
Rafael Espindola3ae00052013-05-13 00:12:11 +0000584 if (D->isExternallyVisible())
Rafael Espindola0e0d0092013-03-14 03:07:35 +0000585 return true;
586
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000587 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +0000588 // If this is a function template and none of its specializations is used,
589 // we should warn.
590 if (FunctionTemplateDecl *Template = FD->getDescribedFunctionTemplate())
591 for (const auto *Spec : Template->specializations())
592 if (ShouldRemoveFromUnused(SemaRef, Spec))
593 return true;
594
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000595 // UnusedFileScopedDecls stores the first declaration.
596 // The declaration may have become definition so check again.
597 const FunctionDecl *DeclToCheck;
598 if (FD->hasBody(DeclToCheck))
599 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
600
601 // Later redecls may add new information resulting in not having to warn,
602 // so check again.
Douglas Gregorec9fd132012-01-14 16:38:05 +0000603 DeclToCheck = FD->getMostRecentDecl();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000604 if (DeclToCheck != FD)
605 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
606 }
607
608 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) {
Eli Friedmana5dfebd2013-09-10 21:10:25 +0000609 // If a variable usable in constant expressions is referenced,
610 // don't warn if it isn't used: if the value of a variable is required
611 // for the computation of a constant expression, it doesn't make sense to
612 // warn even if the variable isn't odr-used. (isReferenced doesn't
613 // precisely reflect that, but it's a decent approximation.)
614 if (VD->isReferenced() &&
Richard Smith715f7a12019-06-11 17:50:32 +0000615 VD->mightBeUsableInConstantExpressions(SemaRef->Context))
Eli Friedmana5dfebd2013-09-10 21:10:25 +0000616 return true;
617
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +0000618 if (VarTemplateDecl *Template = VD->getDescribedVarTemplate())
619 // If this is a variable template and none of its specializations is used,
620 // we should warn.
621 for (const auto *Spec : Template->specializations())
622 if (ShouldRemoveFromUnused(SemaRef, Spec))
623 return true;
624
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000625 // UnusedFileScopedDecls stores the first declaration.
626 // The declaration may have become definition so check again.
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000627 const VarDecl *DeclToCheck = VD->getDefinition();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000628 if (DeclToCheck)
629 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
630
631 // Later redecls may add new information resulting in not having to warn,
632 // so check again.
Douglas Gregorec9fd132012-01-14 16:38:05 +0000633 DeclToCheck = VD->getMostRecentDecl();
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +0000634 if (DeclToCheck != VD)
635 return !SemaRef->ShouldWarnIfUnusedFileScopedDecl(DeclToCheck);
636 }
637
638 return false;
639}
640
Richard Smith405e2db2017-09-20 07:22:00 +0000641static bool isFunctionOrVarDeclExternC(NamedDecl *ND) {
642 if (auto *FD = dyn_cast<FunctionDecl>(ND))
643 return FD->isExternC();
644 return cast<VarDecl>(ND)->isExternC();
645}
646
647/// Determine whether ND is an external-linkage function or variable whose
648/// type has no linkage.
649bool Sema::isExternalWithNoLinkageType(ValueDecl *VD) {
650 // Note: it's not quite enough to check whether VD has UniqueExternalLinkage,
651 // because we also want to catch the case where its type has VisibleNoLinkage,
652 // which does not affect the linkage of VD.
653 return getLangOpts().CPlusPlus && VD->hasExternalFormalLinkage() &&
654 !isExternalFormalLinkage(VD->getType()->getLinkage()) &&
655 !isFunctionOrVarDeclExternC(VD);
656}
657
Richard Smith62f19e72016-06-25 00:15:56 +0000658/// Obtains a sorted list of functions and variables that are undefined but
659/// ODR-used.
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000660void Sema::getUndefinedButUsed(
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000661 SmallVectorImpl<std::pair<NamedDecl *, SourceLocation> > &Undefined) {
Richard Smithd6a04d72016-03-25 21:49:43 +0000662 for (const auto &UndefinedUse : UndefinedButUsed) {
663 NamedDecl *ND = UndefinedUse.first;
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000664
665 // Ignore attributes that have become invalid.
666 if (ND->isInvalidDecl()) continue;
667
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000668 // __attribute__((weakref)) is basically a definition.
669 if (ND->hasAttr<WeakRefAttr>()) continue;
670
Richard Smith57865822017-08-03 19:24:27 +0000671 if (isa<CXXDeductionGuideDecl>(ND))
672 continue;
673
Richard Smith405e2db2017-09-20 07:22:00 +0000674 if (ND->hasAttr<DLLImportAttr>() || ND->hasAttr<DLLExportAttr>()) {
675 // An exported function will always be emitted when defined, so even if
676 // the function is inline, it doesn't have to be emitted in this TU. An
677 // imported function implies that it has been exported somewhere else.
678 continue;
679 }
680
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000681 if (FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) {
682 if (FD->isDefined())
683 continue;
Rafael Espindola3ae00052013-05-13 00:12:11 +0000684 if (FD->isExternallyVisible() &&
Richard Smith405e2db2017-09-20 07:22:00 +0000685 !isExternalWithNoLinkageType(FD) &&
Louis Dionned2695792018-10-04 15:49:42 +0000686 !FD->getMostRecentDecl()->isInlined() &&
687 !FD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000688 continue;
Reid Klecknerc8ae8782018-06-20 21:12:20 +0000689 if (FD->getBuiltinID())
690 continue;
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000691 } else {
Richard Smith62f19e72016-06-25 00:15:56 +0000692 auto *VD = cast<VarDecl>(ND);
693 if (VD->hasDefinition() != VarDecl::DeclarationOnly)
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000694 continue;
Richard Smith405e2db2017-09-20 07:22:00 +0000695 if (VD->isExternallyVisible() &&
696 !isExternalWithNoLinkageType(VD) &&
Louis Dionned2695792018-10-04 15:49:42 +0000697 !VD->getMostRecentDecl()->isInline() &&
698 !VD->hasAttr<ExcludeFromExplicitInstantiationAttr>())
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000699 continue;
Justin Lebar5489f852018-05-17 16:15:07 +0000700
701 // Skip VarDecls that lack formal definitions but which we know are in
702 // fact defined somewhere.
703 if (VD->isKnownToBeDefined())
704 continue;
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000705 }
706
Richard Smithd6a04d72016-03-25 21:49:43 +0000707 Undefined.push_back(std::make_pair(ND, UndefinedUse.second));
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000708 }
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000709}
710
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000711/// checkUndefinedButUsed - Check for undefined objects with internal linkage
712/// or that are inline.
713static void checkUndefinedButUsed(Sema &S) {
714 if (S.UndefinedButUsed.empty()) return;
John McCall83779672011-02-19 02:53:41 +0000715
716 // Collect all the still-undefined entities with internal linkage.
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000717 SmallVector<std::pair<NamedDecl *, SourceLocation>, 16> Undefined;
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000718 S.getUndefinedButUsed(Undefined);
Nick Lewyckyf0f56162013-01-31 03:23:57 +0000719 if (Undefined.empty()) return;
John McCall83779672011-02-19 02:53:41 +0000720
Richard Smith405e2db2017-09-20 07:22:00 +0000721 for (auto Undef : Undefined) {
722 ValueDecl *VD = cast<ValueDecl>(Undef.first);
723 SourceLocation UseLoc = Undef.second;
John McCall83779672011-02-19 02:53:41 +0000724
Richard Smith405e2db2017-09-20 07:22:00 +0000725 if (S.isExternalWithNoLinkageType(VD)) {
726 // C++ [basic.link]p8:
727 // A type without linkage shall not be used as the type of a variable
728 // or function with external linkage unless
729 // -- the entity has C language linkage
730 // -- the entity is not odr-used or is defined in the same TU
731 //
732 // As an extension, accept this in cases where the type is externally
733 // visible, since the function or variable actually can be defined in
734 // another translation unit in that case.
735 S.Diag(VD->getLocation(), isExternallyVisible(VD->getType()->getLinkage())
736 ? diag::ext_undefined_internal_type
737 : diag::err_undefined_internal_type)
738 << isa<VarDecl>(VD) << VD;
739 } else if (!VD->isExternallyVisible()) {
740 // FIXME: We can promote this to an error. The function or variable can't
741 // be defined anywhere else, so the program must necessarily violate the
742 // one definition rule.
743 S.Diag(VD->getLocation(), diag::warn_undefined_internal)
744 << isa<VarDecl>(VD) << VD;
745 } else if (auto *FD = dyn_cast<FunctionDecl>(VD)) {
James Y Knight5b218ff2016-06-25 16:40:53 +0000746 (void)FD;
Richard Smith62f19e72016-06-25 00:15:56 +0000747 assert(FD->getMostRecentDecl()->isInlined() &&
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000748 "used object requires definition but isn't inline or internal?");
Richard Smith62f19e72016-06-25 00:15:56 +0000749 // FIXME: This is ill-formed; we should reject.
Richard Smith405e2db2017-09-20 07:22:00 +0000750 S.Diag(VD->getLocation(), diag::warn_undefined_inline) << VD;
Richard Smith62f19e72016-06-25 00:15:56 +0000751 } else {
Richard Smith405e2db2017-09-20 07:22:00 +0000752 assert(cast<VarDecl>(VD)->getMostRecentDecl()->isInline() &&
Richard Smith62f19e72016-06-25 00:15:56 +0000753 "used var requires definition but isn't inline or internal?");
Richard Smith405e2db2017-09-20 07:22:00 +0000754 S.Diag(VD->getLocation(), diag::err_undefined_inline_var) << VD;
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +0000755 }
Richard Smith405e2db2017-09-20 07:22:00 +0000756 if (UseLoc.isValid())
757 S.Diag(UseLoc, diag::note_used_here);
John McCall83779672011-02-19 02:53:41 +0000758 }
Richard Smithd6a04d72016-03-25 21:49:43 +0000759
760 S.UndefinedButUsed.clear();
John McCall83779672011-02-19 02:53:41 +0000761}
762
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000763void Sema::LoadExternalWeakUndeclaredIdentifiers() {
764 if (!ExternalSource)
765 return;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000766
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000767 SmallVector<std::pair<IdentifierInfo *, WeakInfo>, 4> WeakIDs;
768 ExternalSource->ReadWeakUndeclaredIdentifiers(WeakIDs);
Chandler Carruthf85d9822015-03-26 08:32:49 +0000769 for (auto &WeakID : WeakIDs)
770 WeakUndeclaredIdentifiers.insert(WeakID);
Douglas Gregor1c4bfe52011-07-28 18:09:57 +0000771}
772
Daniel Jasper0baec5492012-06-06 08:32:04 +0000773
774typedef llvm::DenseMap<const CXXRecordDecl*, bool> RecordCompleteMap;
775
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000776/// Returns true, if all methods and nested classes of the given
Daniel Jasper0baec5492012-06-06 08:32:04 +0000777/// CXXRecordDecl are defined in this translation unit.
778///
779/// Should only be called from ActOnEndOfTranslationUnit so that all
780/// definitions are actually read.
781static bool MethodsAndNestedClassesComplete(const CXXRecordDecl *RD,
782 RecordCompleteMap &MNCComplete) {
783 RecordCompleteMap::iterator Cache = MNCComplete.find(RD);
784 if (Cache != MNCComplete.end())
785 return Cache->second;
786 if (!RD->isCompleteDefinition())
787 return false;
788 bool Complete = true;
789 for (DeclContext::decl_iterator I = RD->decls_begin(),
790 E = RD->decls_end();
791 I != E && Complete; ++I) {
792 if (const CXXMethodDecl *M = dyn_cast<CXXMethodDecl>(*I))
Richard Smitha31174e2017-11-01 04:52:12 +0000793 Complete = M->isDefined() || M->isDefaulted() ||
794 (M->isPure() && !isa<CXXDestructorDecl>(M));
Daniel Jaspere99c2bf2012-06-14 20:56:06 +0000795 else if (const FunctionTemplateDecl *F = dyn_cast<FunctionTemplateDecl>(*I))
Nico Weber4bde6c22015-06-18 20:09:49 +0000796 // If the template function is marked as late template parsed at this
797 // point, it has not been instantiated and therefore we have not
798 // performed semantic analysis on it yet, so we cannot know if the type
799 // can be considered complete.
Ehsan Akhgari4b5ca9a2014-10-11 00:24:15 +0000800 Complete = !F->getTemplatedDecl()->isLateTemplateParsed() &&
801 F->getTemplatedDecl()->isDefined();
Daniel Jasper0baec5492012-06-06 08:32:04 +0000802 else if (const CXXRecordDecl *R = dyn_cast<CXXRecordDecl>(*I)) {
803 if (R->isInjectedClassName())
804 continue;
805 if (R->hasDefinition())
806 Complete = MethodsAndNestedClassesComplete(R->getDefinition(),
807 MNCComplete);
808 else
809 Complete = false;
810 }
811 }
812 MNCComplete[RD] = Complete;
813 return Complete;
814}
815
Adrian Prantl9fc8faf2018-05-09 01:00:01 +0000816/// Returns true, if the given CXXRecordDecl is fully defined in this
Daniel Jasper0baec5492012-06-06 08:32:04 +0000817/// translation unit, i.e. all methods are defined or pure virtual and all
818/// friends, friend functions and nested classes are fully defined in this
819/// translation unit.
820///
821/// Should only be called from ActOnEndOfTranslationUnit so that all
822/// definitions are actually read.
823static bool IsRecordFullyDefined(const CXXRecordDecl *RD,
824 RecordCompleteMap &RecordsComplete,
825 RecordCompleteMap &MNCComplete) {
826 RecordCompleteMap::iterator Cache = RecordsComplete.find(RD);
827 if (Cache != RecordsComplete.end())
828 return Cache->second;
829 bool Complete = MethodsAndNestedClassesComplete(RD, MNCComplete);
830 for (CXXRecordDecl::friend_iterator I = RD->friend_begin(),
831 E = RD->friend_end();
832 I != E && Complete; ++I) {
833 // Check if friend classes and methods are complete.
834 if (TypeSourceInfo *TSI = (*I)->getFriendType()) {
835 // Friend classes are available as the TypeSourceInfo of the FriendDecl.
836 if (CXXRecordDecl *FriendD = TSI->getType()->getAsCXXRecordDecl())
837 Complete = MethodsAndNestedClassesComplete(FriendD, MNCComplete);
838 else
839 Complete = false;
840 } else {
841 // Friend functions are available through the NamedDecl of FriendDecl.
842 if (const FunctionDecl *FD =
843 dyn_cast<FunctionDecl>((*I)->getFriendDecl()))
844 Complete = FD->isDefined();
845 else
846 // This is a template friend, give up.
847 Complete = false;
848 }
849 }
850 RecordsComplete[RD] = Complete;
851 return Complete;
852}
853
Nico Weber72889432014-09-06 01:25:55 +0000854void Sema::emitAndClearUnusedLocalTypedefWarnings() {
855 if (ExternalSource)
856 ExternalSource->ReadUnusedLocalTypedefNameCandidates(
857 UnusedLocalTypedefNameCandidates);
858 for (const TypedefNameDecl *TD : UnusedLocalTypedefNameCandidates) {
859 if (TD->isReferenced())
860 continue;
861 Diag(TD->getLocation(), diag::warn_unused_local_typedef)
862 << isa<TypeAliasDecl>(TD) << TD->getDeclName();
863 }
864 UnusedLocalTypedefNameCandidates.clear();
865}
866
Richard Smithe03a6542017-07-05 01:42:07 +0000867/// This is called before the very first declaration in the translation unit
868/// is parsed. Note that the ASTContext may have already injected some
869/// declarations.
870void Sema::ActOnStartOfTranslationUnit() {
Richard Smithac9f7fb2018-09-15 01:59:39 +0000871 if (getLangOpts().ModulesTS &&
872 (getLangOpts().getCompilingModule() == LangOptions::CMK_ModuleInterface ||
873 getLangOpts().getCompilingModule() == LangOptions::CMK_None)) {
Richard Smithd652bdd2019-04-14 08:06:59 +0000874 // We start in an implied global module fragment.
Richard Smithdd8b5332017-09-04 05:37:53 +0000875 SourceLocation StartOfTU =
876 SourceMgr.getLocForStartOfFile(SourceMgr.getMainFileID());
Richard Smithd652bdd2019-04-14 08:06:59 +0000877 ActOnGlobalModuleFragmentDecl(StartOfTU);
878 ModuleScopes.back().ImplicitGlobalModuleFragment = true;
Richard Smithe03a6542017-07-05 01:42:07 +0000879 }
880}
881
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000882void Sema::ActOnEndOfTranslationUnitFragment(TUFragmentKind Kind) {
883 // No explicit actions are required at the end of the global module fragment.
884 if (Kind == TUFragmentKind::Global)
Douglas Gregorc459b512012-08-17 22:17:36 +0000885 return;
886
Reid Kleckner24bd88c2018-03-26 18:22:47 +0000887 // Transfer late parsed template instantiations over to the pending template
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000888 // instantiation list. During normal compilation, the late template parser
Reid Kleckner24bd88c2018-03-26 18:22:47 +0000889 // will be installed and instantiating these templates will succeed.
890 //
891 // If we are building a TU prefix for serialization, it is also safe to
892 // transfer these over, even though they are not parsed. The end of the TU
893 // should be outside of any eager template instantiation scope, so when this
894 // AST is deserialized, these templates will not be parsed until the end of
895 // the combined TU.
896 PendingInstantiations.insert(PendingInstantiations.end(),
897 LateParsedInstantiations.begin(),
898 LateParsedInstantiations.end());
899 LateParsedInstantiations.clear();
900
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000901 // If DefinedUsedVTables ends up marking any virtual member functions it
902 // might lead to more pending template instantiations, which we then need
903 // to instantiate.
904 DefineUsedVTables();
905
906 // C++: Perform implicit template instantiations.
907 //
908 // FIXME: When we perform these implicit instantiations, we do not
909 // carefully keep track of the point of instantiation (C++ [temp.point]).
910 // This means that name lookup that occurs within the template
911 // instantiation will always happen at the end of the translation unit,
912 // so it will find some names that are not required to be found. This is
913 // valid, but we could do better by diagnosing if an instantiation uses a
914 // name that was not visible at its first point of instantiation.
915 if (ExternalSource) {
916 // Load pending instantiations from the external source.
917 SmallVector<PendingImplicitInstantiation, 4> Pending;
918 ExternalSource->ReadPendingInstantiations(Pending);
919 for (auto PII : Pending)
920 if (auto Func = dyn_cast<FunctionDecl>(PII.first))
921 Func->setInstantiationIsPending(true);
922 PendingInstantiations.insert(PendingInstantiations.begin(),
923 Pending.begin(), Pending.end());
924 }
925
926 {
927 llvm::TimeTraceScope TimeScope("PerformPendingInstantiations",
928 StringRef(""));
929 PerformPendingInstantiations();
930 }
931
Alexey Bataev729e2422019-08-23 16:11:14 +0000932 // Finalize analysis of OpenMP-specific constructs.
933 if (LangOpts.OpenMP)
934 finalizeOpenMPDelayedAnalysis();
935
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000936 assert(LateParsedInstantiations.empty() &&
937 "end of TU template instantiation should not create more "
938 "late-parsed templates");
Ilya Biryukovaeae71c2019-10-09 10:00:05 +0000939
940 // Report diagnostics for uncorrected delayed typos. Ideally all of them
941 // should have been corrected by that time, but it is very hard to cover all
942 // cases in practice.
943 for (const auto &Typo : DelayedTypos) {
944 // We pass an empty TypoCorrection to indicate no correction was performed.
945 Typo.second.DiagHandler(TypoCorrection());
946 }
947 DelayedTypos.clear();
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000948}
949
950/// ActOnEndOfTranslationUnit - This is called at the very end of the
951/// translation unit when EOF is reached and all but the top-level scope is
952/// popped.
953void Sema::ActOnEndOfTranslationUnit() {
954 assert(DelayedDiagnostics.getCurrentPool() == nullptr
955 && "reached end of translation unit with a pool attached?");
956
957 // If code completion is enabled, don't perform any end-of-translation-unit
958 // work.
959 if (PP.isCodeCompletionEnabled())
960 return;
961
Richard Smith0e5d7b82013-07-25 23:08:39 +0000962 // Complete translation units and modules define vtables and perform implicit
963 // instantiations. PCH files do not.
964 if (TUKind != TU_Prefix) {
Argyrios Kyrtzidisb6c6a582012-02-07 16:50:53 +0000965 DiagnoseUseOfUnimplementedSelectors();
966
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000967 ActOnEndOfTranslationUnitFragment(
968 !ModuleScopes.empty() && ModuleScopes.back().Module->Kind ==
969 Module::PrivateModuleFragment
970 ? TUFragmentKind::Private
971 : TUFragmentKind::Normal);
Reid Kleckner24bd88c2018-03-26 18:22:47 +0000972
Reid Kleckner89bd8d62014-10-22 17:50:19 +0000973 if (LateTemplateParserCleanup)
974 LateTemplateParserCleanup(OpaqueParser);
975
Alp Tokerae3a9442013-10-18 05:54:19 +0000976 CheckDelayedMemberExceptionSpecs();
Richard Smitha5bbbfe2019-04-18 21:12:54 +0000977 } else {
978 // If we are building a TU prefix for serialization, it is safe to transfer
979 // these over, even though they are not parsed. The end of the TU should be
980 // outside of any eager template instantiation scope, so when this AST is
981 // deserialized, these templates will not be parsed until the end of the
982 // combined TU.
983 PendingInstantiations.insert(PendingInstantiations.end(),
984 LateParsedInstantiations.begin(),
985 LateParsedInstantiations.end());
986 LateParsedInstantiations.clear();
Nick Lewyckyef4f4562010-11-25 00:35:20 +0000987 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +0000988
Alex Lorenz45b40142017-07-28 14:41:21 +0000989 DiagnoseUnterminatedPragmaPack();
Alex Lorenz9e7bf162017-04-18 14:33:39 +0000990 DiagnoseUnterminatedPragmaAttribute();
991
Alp Tokerae3a9442013-10-18 05:54:19 +0000992 // All delayed member exception specs should be checked or we end up accepting
993 // incompatible declarations.
Richard Smith5159bbad2018-09-05 22:30:37 +0000994 assert(DelayedOverridingExceptionSpecChecks.empty());
995 assert(DelayedEquivalentExceptionSpecChecks.empty());
Alp Tokerae3a9442013-10-18 05:54:19 +0000996
Hans Wennborg99000c22015-08-15 01:18:16 +0000997 // All dllexport classes should have been processed already.
998 assert(DelayedDllExportClasses.empty());
Hans Wennborgc5877e92019-08-01 08:01:09 +0000999 assert(DelayedDllExportMemberFunctions.empty());
Hans Wennborg99000c22015-08-15 01:18:16 +00001000
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +00001001 // Remove file scoped decls that turned out to be used.
Daniel Jasper9ba6f9b2013-04-30 06:43:16 +00001002 UnusedFileScopedDecls.erase(
Craig Topperc3ec1492014-05-26 06:22:03 +00001003 std::remove_if(UnusedFileScopedDecls.begin(nullptr, true),
Daniel Jasper9ba6f9b2013-04-30 06:43:16 +00001004 UnusedFileScopedDecls.end(),
Richard Smith2c27df72017-03-23 23:17:58 +00001005 [this](const DeclaratorDecl *DD) {
1006 return ShouldRemoveFromUnused(this, DD);
1007 }),
Daniel Jasper9ba6f9b2013-04-30 06:43:16 +00001008 UnusedFileScopedDecls.end());
Douglas Gregorfb8b27d2010-04-09 17:41:13 +00001009
Douglas Gregor69f74f82011-08-25 22:30:56 +00001010 if (TUKind == TU_Prefix) {
1011 // Translation unit prefixes don't need any of the checking below.
Vassil Vassilev45bf62f2016-10-17 10:15:25 +00001012 if (!PP.isIncrementalProcessingEnabled())
1013 TUScope = nullptr;
Argyrios Kyrtzidisee1afa32010-08-05 09:48:08 +00001014 return;
Douglas Gregorb14904c2010-08-13 22:48:40 +00001015 }
Argyrios Kyrtzidisee1afa32010-08-05 09:48:08 +00001016
Chris Lattner0c797362009-09-08 18:19:27 +00001017 // Check for #pragma weak identifiers that were never declared
Douglas Gregor1c4bfe52011-07-28 18:09:57 +00001018 LoadExternalWeakUndeclaredIdentifiers();
Chandler Carruthf85d9822015-03-26 08:32:49 +00001019 for (auto WeakID : WeakUndeclaredIdentifiers) {
1020 if (WeakID.second.getUsed())
1021 continue;
Mike Stump11289f42009-09-09 15:08:12 +00001022
Alexander Musmanfbbc0b82015-09-18 07:40:22 +00001023 Decl *PrevDecl = LookupSingleName(TUScope, WeakID.first, SourceLocation(),
1024 LookupOrdinaryName);
1025 if (PrevDecl != nullptr &&
1026 !(isa<FunctionDecl>(PrevDecl) || isa<VarDecl>(PrevDecl)))
1027 Diag(WeakID.second.getLocation(), diag::warn_attribute_wrong_decl_type)
1028 << "'weak'" << ExpectedVariableOrFunction;
1029 else
1030 Diag(WeakID.second.getLocation(), diag::warn_weak_identifier_undeclared)
1031 << WeakID.first;
Ryan Flynn7d470f32009-07-30 03:15:39 +00001032 }
1033
Argyrios Kyrtzidisffb35582013-03-14 04:44:56 +00001034 if (LangOpts.CPlusPlus11 &&
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00001035 !Diags.isIgnored(diag::warn_delegating_ctor_cycle, SourceLocation()))
Argyrios Kyrtzidisffb35582013-03-14 04:44:56 +00001036 CheckDelegatingCtorCycles();
1037
Richard Smithd6a04d72016-03-25 21:49:43 +00001038 if (!Diags.hasErrorOccurred()) {
1039 if (ExternalSource)
1040 ExternalSource->ReadUndefinedButUsed(UndefinedButUsed);
1041 checkUndefinedButUsed(*this);
1042 }
1043
Richard Smithd652bdd2019-04-14 08:06:59 +00001044 // A global-module-fragment is only permitted within a module unit.
1045 bool DiagnosedMissingModuleDeclaration = false;
1046 if (!ModuleScopes.empty() &&
1047 ModuleScopes.back().Module->Kind == Module::GlobalModuleFragment &&
1048 !ModuleScopes.back().ImplicitGlobalModuleFragment) {
1049 Diag(ModuleScopes.back().BeginLoc,
1050 diag::err_module_declaration_missing_after_global_module_introducer);
1051 DiagnosedMissingModuleDeclaration = true;
1052 }
1053
Douglas Gregor69f74f82011-08-25 22:30:56 +00001054 if (TUKind == TU_Module) {
Richard Smith18057cb2017-10-11 00:36:56 +00001055 // If we are building a module interface unit, we need to have seen the
1056 // module declaration by now.
1057 if (getLangOpts().getCompilingModule() ==
1058 LangOptions::CMK_ModuleInterface &&
Richard Smithd6509cf2018-09-15 01:21:15 +00001059 (ModuleScopes.empty() ||
Richard Smitha5bbbfe2019-04-18 21:12:54 +00001060 !ModuleScopes.back().Module->isModulePurview()) &&
Richard Smithd652bdd2019-04-14 08:06:59 +00001061 !DiagnosedMissingModuleDeclaration) {
Richard Smith18057cb2017-10-11 00:36:56 +00001062 // FIXME: Make a better guess as to where to put the module declaration.
1063 Diag(getSourceManager().getLocForStartOfFile(
1064 getSourceManager().getMainFileID()),
1065 diag::err_module_declaration_missing);
1066 }
1067
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001068 // If we are building a module, resolve all of the exported declarations
1069 // now.
1070 if (Module *CurrentModule = PP.getCurrentModule()) {
1071 ModuleMap &ModMap = PP.getHeaderSearchInfo().getModuleMap();
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001072
Dmitri Gribenkof8579502013-01-12 19:30:44 +00001073 SmallVector<Module *, 2> Stack;
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001074 Stack.push_back(CurrentModule);
1075 while (!Stack.empty()) {
Robert Wilhelm25284cc2013-08-23 16:11:15 +00001076 Module *Mod = Stack.pop_back_val();
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001077
Douglas Gregorfb912652013-03-20 21:10:35 +00001078 // Resolve the exported declarations and conflicts.
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001079 // FIXME: Actually complain, once we figure out how to teach the
Douglas Gregorfb912652013-03-20 21:10:35 +00001080 // diagnostic client to deal with complaints in the module map at this
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001081 // point.
1082 ModMap.resolveExports(Mod, /*Complain=*/false);
Daniel Jasperba7f2f72013-09-24 09:14:14 +00001083 ModMap.resolveUses(Mod, /*Complain=*/false);
Douglas Gregorfb912652013-03-20 21:10:35 +00001084 ModMap.resolveConflicts(Mod, /*Complain=*/false);
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001085
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001086 // Queue the submodules, so their exports will also be resolved.
Benjamin Kramerf367dd92015-06-12 15:31:50 +00001087 Stack.append(Mod->submodule_begin(), Mod->submodule_end());
Douglas Gregor2b82c2a2011-12-02 01:47:07 +00001088 }
1089 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001090
Nico Weber72889432014-09-06 01:25:55 +00001091 // Warnings emitted in ActOnEndOfTranslationUnit() should be emitted for
1092 // modules when they are built, not every time they are used.
1093 emitAndClearUnusedLocalTypedefWarnings();
Douglas Gregor69f74f82011-08-25 22:30:56 +00001094 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001095
Douglas Gregor0760fa12009-03-10 23:43:53 +00001096 // C99 6.9.2p2:
1097 // A declaration of an identifier for an object that has file
1098 // scope without an initializer, and without a storage-class
1099 // specifier or with the storage-class specifier static,
1100 // constitutes a tentative definition. If a translation unit
1101 // contains one or more tentative definitions for an identifier,
1102 // and the translation unit contains no external definition for
1103 // that identifier, then the behavior is exactly as if the
1104 // translation unit contains a file scope declaration of that
1105 // identifier, with the composite type as of the end of the
1106 // translation unit, with an initializer equal to 0.
Sebastian Redl35351a92010-01-31 22:27:38 +00001107 llvm::SmallSet<VarDecl *, 32> Seen;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001108 for (TentativeDefinitionsType::iterator
Douglas Gregoreb08bd42011-07-27 20:58:46 +00001109 T = TentativeDefinitions.begin(ExternalSource),
1110 TEnd = TentativeDefinitions.end();
Richard Smithf5262c62018-06-28 01:57:04 +00001111 T != TEnd; ++T) {
Douglas Gregoreb08bd42011-07-27 20:58:46 +00001112 VarDecl *VD = (*T)->getActingDefinition();
Mike Stump11289f42009-09-09 15:08:12 +00001113
Sebastian Redl35351a92010-01-31 22:27:38 +00001114 // If the tentative definition was completed, getActingDefinition() returns
1115 // null. If we've already seen this variable before, insert()'s second
1116 // return value is false.
David Blaikie82e95a32014-11-19 07:49:47 +00001117 if (!VD || VD->isInvalidDecl() || !Seen.insert(VD).second)
Douglas Gregorbeecd582009-04-21 17:11:58 +00001118 continue;
1119
Mike Stump11289f42009-09-09 15:08:12 +00001120 if (const IncompleteArrayType *ArrayT
Douglas Gregorbeecd582009-04-21 17:11:58 +00001121 = Context.getAsIncompleteArrayType(VD->getType())) {
Chris Lattner0c797362009-09-08 18:19:27 +00001122 // Set the length of the array to 1 (C99 6.9.2p5).
1123 Diag(VD->getLocation(), diag::warn_tentative_incomplete_array);
1124 llvm::APInt One(Context.getTypeSize(Context.getSizeType()), true);
Richard Smith772e2662019-10-04 01:25:59 +00001125 QualType T = Context.getConstantArrayType(ArrayT->getElementType(), One,
1126 nullptr, ArrayType::Normal, 0);
Chris Lattner0c797362009-09-08 18:19:27 +00001127 VD->setType(T);
Mike Stump11289f42009-09-09 15:08:12 +00001128 } else if (RequireCompleteType(VD->getLocation(), VD->getType(),
Douglas Gregorbeecd582009-04-21 17:11:58 +00001129 diag::err_tentative_def_incomplete_type))
1130 VD->setInvalidDecl();
1131
Richard Smith7873de02016-08-11 22:25:46 +00001132 // No initialization is performed for a tentative definition.
Richard Smith3997b1b2016-08-12 01:55:21 +00001133 CheckCompleteVariableDeclaration(VD);
Eli Friedman7d14b3c2012-10-23 20:19:32 +00001134
Douglas Gregorbeecd582009-04-21 17:11:58 +00001135 // Notify the consumer that we've completed a tentative definition.
1136 if (!VD->isInvalidDecl())
1137 Consumer.CompleteTentativeDefinition(VD);
Douglas Gregor0760fa12009-03-10 23:43:53 +00001138 }
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001139
1140 // If there were errors, disable 'unused' warnings since they will mostly be
Richard Smithf5262c62018-06-28 01:57:04 +00001141 // noise. Don't warn for a use from a module: either we should warn on all
1142 // file-scope declarations in modules or not at all, but whether the
1143 // declaration is used is immaterial.
1144 if (!Diags.hasErrorOccurred() && TUKind != TU_Module) {
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001145 // Output warning for unused file scoped decls.
Douglas Gregora94a1542011-07-27 21:45:57 +00001146 for (UnusedFileScopedDeclsType::iterator
1147 I = UnusedFileScopedDecls.begin(ExternalSource),
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001148 E = UnusedFileScopedDecls.end(); I != E; ++I) {
Douglas Gregora94a1542011-07-27 21:45:57 +00001149 if (ShouldRemoveFromUnused(this, *I))
1150 continue;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001151
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001152 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(*I)) {
1153 const FunctionDecl *DiagD;
1154 if (!FD->hasBody(DiagD))
1155 DiagD = FD;
Argyrios Kyrtzidise0283142011-03-03 17:47:42 +00001156 if (DiagD->isDeleted())
1157 continue; // Deleted functions are supposed to be unused.
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001158 if (DiagD->isReferenced()) {
1159 if (isa<CXXMethodDecl>(DiagD))
1160 Diag(DiagD->getLocation(), diag::warn_unneeded_member_function)
1161 << DiagD->getDeclName();
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001162 else {
Rafael Espindola6ae7e502013-04-03 19:27:57 +00001163 if (FD->getStorageClass() == SC_Static &&
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001164 !FD->isInlineSpecified() &&
Eli Friedman5ba37d52013-08-22 00:27:10 +00001165 !SourceMgr.isInMainFile(
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001166 SourceMgr.getExpansionLoc(FD->getLocation())))
Nico Weber63816332014-07-26 23:20:08 +00001167 Diag(DiagD->getLocation(),
1168 diag::warn_unneeded_static_internal_decl)
1169 << DiagD->getDeclName();
Fariborz Jahanian91fc39e2012-06-27 19:43:29 +00001170 else
1171 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1172 << /*function*/0 << DiagD->getDeclName();
1173 }
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001174 } else {
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +00001175 if (FD->getDescribedFunctionTemplate())
1176 Diag(DiagD->getLocation(), diag::warn_unused_template)
1177 << /*function*/0 << DiagD->getDeclName();
1178 else
1179 Diag(DiagD->getLocation(),
1180 isa<CXXMethodDecl>(DiagD) ? diag::warn_unused_member_function
1181 : diag::warn_unused_function)
1182 << DiagD->getDeclName();
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001183 }
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001184 } else {
1185 const VarDecl *DiagD = cast<VarDecl>(*I)->getDefinition();
1186 if (!DiagD)
1187 DiagD = cast<VarDecl>(*I);
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001188 if (DiagD->isReferenced()) {
1189 Diag(DiagD->getLocation(), diag::warn_unneeded_internal_decl)
1190 << /*variable*/1 << DiagD->getDeclName();
Daniel Jasperc531dae2013-09-11 10:37:35 +00001191 } else if (DiagD->getType().isConstQualified()) {
Erik Verbruggen89aa7eb2016-10-28 08:28:42 +00001192 const SourceManager &SM = SourceMgr;
1193 if (SM.getMainFileID() != SM.getFileID(DiagD->getLocation()) ||
1194 !PP.getLangOpts().IsHeaderFile)
1195 Diag(DiagD->getLocation(), diag::warn_unused_const_variable)
1196 << DiagD->getDeclName();
Eli Friedman5ef21752013-09-10 03:05:56 +00001197 } else {
Vassil Vassilev64e1e1e2017-05-09 11:25:41 +00001198 if (DiagD->getDescribedVarTemplate())
1199 Diag(DiagD->getLocation(), diag::warn_unused_template)
1200 << /*variable*/1 << DiagD->getDeclName();
1201 else
1202 Diag(DiagD->getLocation(), diag::warn_unused_variable)
Matt Beaumont-Gaye1368a12013-04-10 00:47:10 +00001203 << DiagD->getDeclName();
Argyrios Kyrtzidis16180232011-04-19 19:51:10 +00001204 }
Argyrios Kyrtzidis77fd99f2011-01-31 07:04:37 +00001205 }
Argyrios Kyrtzidis1b30d9c2010-08-15 01:15:20 +00001206 }
John McCall83779672011-02-19 02:53:41 +00001207
Nico Weber72889432014-09-06 01:25:55 +00001208 emitAndClearUnusedLocalTypedefWarnings();
Argyrios Kyrtzidis35672e72010-08-13 18:42:17 +00001209 }
Douglas Gregorb14904c2010-08-13 22:48:40 +00001210
Alp Tokerd4a3f0e2014-06-15 23:30:39 +00001211 if (!Diags.isIgnored(diag::warn_unused_private_field, SourceLocation())) {
Richard Smithf5262c62018-06-28 01:57:04 +00001212 // FIXME: Load additional unused private field candidates from the external
1213 // source.
Daniel Jasper0baec5492012-06-06 08:32:04 +00001214 RecordCompleteMap RecordsComplete;
1215 RecordCompleteMap MNCComplete;
1216 for (NamedDeclSetType::iterator I = UnusedPrivateFields.begin(),
1217 E = UnusedPrivateFields.end(); I != E; ++I) {
1218 const NamedDecl *D = *I;
1219 const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext());
1220 if (RD && !RD->isUnion() &&
1221 IsRecordFullyDefined(RD, RecordsComplete, MNCComplete)) {
1222 Diag(D->getLocation(), diag::warn_unused_private_field)
1223 << D->getDeclName();
1224 }
1225 }
1226 }
1227
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00001228 if (!Diags.isIgnored(diag::warn_mismatched_delete_new, SourceLocation())) {
1229 if (ExternalSource)
1230 ExternalSource->ReadMismatchingDeleteExpressions(DeleteExprs);
1231 for (const auto &DeletedFieldInfo : DeleteExprs) {
1232 for (const auto &DeleteExprLoc : DeletedFieldInfo.second) {
1233 AnalyzeDeleteExprMismatch(DeletedFieldInfo.first, DeleteExprLoc.first,
1234 DeleteExprLoc.second);
1235 }
1236 }
1237 }
1238
Richard Smithb2bc2e62011-02-21 20:05:19 +00001239 // Check we've noticed that we're no longer parsing the initializer for every
1240 // variable. If we miss cases, then at best we have a performance issue and
1241 // at worst a rejects-valid bug.
1242 assert(ParsingInitForAutoVars.empty() &&
1243 "Didn't unmark var as having its initializer parsed");
1244
Vassil Vassilev45bf62f2016-10-17 10:15:25 +00001245 if (!PP.isIncrementalProcessingEnabled())
1246 TUScope = nullptr;
Chris Lattnerf4404402008-08-23 03:19:52 +00001247}
1248
1249
Chris Lattnerc11438c2006-08-18 05:17:52 +00001250//===----------------------------------------------------------------------===//
Chris Lattnereaafe1222006-11-10 05:17:58 +00001251// Helper functions.
1252//===----------------------------------------------------------------------===//
1253
Anders Carlssonb26ab812009-08-08 17:45:02 +00001254DeclContext *Sema::getFunctionLevelDeclContext() {
John McCallb8788012009-12-19 10:53:49 +00001255 DeclContext *DC = CurContext;
Mike Stump11289f42009-09-09 15:08:12 +00001256
Eli Friedman73a04092012-01-07 04:59:52 +00001257 while (true) {
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00001258 if (isa<BlockDecl>(DC) || isa<EnumDecl>(DC) || isa<CapturedDecl>(DC)) {
Eli Friedman73a04092012-01-07 04:59:52 +00001259 DC = DC->getParent();
1260 } else if (isa<CXXMethodDecl>(DC) &&
Douglas Gregor1a22d282012-02-12 17:34:23 +00001261 cast<CXXMethodDecl>(DC)->getOverloadedOperator() == OO_Call &&
Eli Friedman73a04092012-01-07 04:59:52 +00001262 cast<CXXRecordDecl>(DC->getParent())->isLambda()) {
1263 DC = DC->getParent()->getParent();
1264 }
1265 else break;
1266 }
Mike Stump11289f42009-09-09 15:08:12 +00001267
Anders Carlssonb26ab812009-08-08 17:45:02 +00001268 return DC;
1269}
1270
Chris Lattner79413952008-12-04 23:50:19 +00001271/// getCurFunctionDecl - If inside of a function body, this returns a pointer
1272/// to the function decl for the function being parsed. If we're currently
1273/// in a 'block', this returns the containing context.
1274FunctionDecl *Sema::getCurFunctionDecl() {
Anders Carlssonb26ab812009-08-08 17:45:02 +00001275 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner79413952008-12-04 23:50:19 +00001276 return dyn_cast<FunctionDecl>(DC);
1277}
1278
Daniel Dunbar6e8aa532008-08-11 05:35:13 +00001279ObjCMethodDecl *Sema::getCurMethodDecl() {
Anders Carlssonb26ab812009-08-08 17:45:02 +00001280 DeclContext *DC = getFunctionLevelDeclContext();
Fariborz Jahaniandeac9ac2013-05-31 21:51:12 +00001281 while (isa<RecordDecl>(DC))
1282 DC = DC->getParent();
Steve Naroffecf2bb82008-11-17 16:28:52 +00001283 return dyn_cast<ObjCMethodDecl>(DC);
Daniel Dunbar6e8aa532008-08-11 05:35:13 +00001284}
Chris Lattner79413952008-12-04 23:50:19 +00001285
1286NamedDecl *Sema::getCurFunctionOrMethodDecl() {
Anders Carlssonb26ab812009-08-08 17:45:02 +00001287 DeclContext *DC = getFunctionLevelDeclContext();
Chris Lattner79413952008-12-04 23:50:19 +00001288 if (isa<ObjCMethodDecl>(DC) || isa<FunctionDecl>(DC))
Douglas Gregor6e6ad602009-01-20 01:17:11 +00001289 return cast<NamedDecl>(DC);
Craig Topperc3ec1492014-05-26 06:22:03 +00001290 return nullptr;
Chris Lattner79413952008-12-04 23:50:19 +00001291}
1292
Daniel Dunbard671ab92012-03-14 09:49:32 +00001293void Sema::EmitCurrentDiagnostic(unsigned DiagID) {
1294 // FIXME: It doesn't make sense to me that DiagID is an incoming argument here
1295 // and yet we also use the current diag ID on the DiagnosticsEngine. This has
1296 // been made more painfully obvious by the refactor that introduced this
1297 // function, but it is possible that the incoming argument can be
Richard Smith51ec0cf2017-02-21 01:17:38 +00001298 // eliminated. If it truly cannot be (for example, there is some reentrancy
Daniel Dunbard671ab92012-03-14 09:49:32 +00001299 // issue I am not seeing yet), then there should at least be a clarifying
1300 // comment somewhere.
David Blaikie05785d12013-02-20 22:23:23 +00001301 if (Optional<TemplateDeductionInfo*> Info = isSFINAEContext()) {
Daniel Dunbard671ab92012-03-14 09:49:32 +00001302 switch (DiagnosticIDs::getDiagnosticSFINAEResponse(
1303 Diags.getCurrentDiagID())) {
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00001304 case DiagnosticIDs::SFINAE_Report:
Richard Smith38c0e042011-10-19 00:07:01 +00001305 // We'll report the diagnostic below.
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001306 break;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001307
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00001308 case DiagnosticIDs::SFINAE_SubstitutionFailure:
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001309 // Count this failure so that we know that template argument deduction
1310 // has failed.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001311 ++NumSFINAEErrors;
Richard Smith9ca64612012-05-07 09:03:25 +00001312
1313 // Make a copy of this suppressed diagnostic and store it with the
1314 // template-deduction information.
1315 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1316 Diagnostic DiagInfo(&Diags);
1317 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1318 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1319 }
1320
Dmitri Gribenko20f45ed2019-09-12 12:16:43 +00001321 Diags.setLastDiagnosticIgnored(true);
Daniel Dunbard671ab92012-03-14 09:49:32 +00001322 Diags.Clear();
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001323 return;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001324
Richard Smith38c0e042011-10-19 00:07:01 +00001325 case DiagnosticIDs::SFINAE_AccessControl: {
1326 // Per C++ Core Issue 1170, access control is part of SFINAE.
Daniel Dunbara25002f2012-03-13 18:30:54 +00001327 // Additionally, the AccessCheckingSFINAE flag can be used to temporarily
Richard Smith38c0e042011-10-19 00:07:01 +00001328 // make access control a part of SFINAE for the purposes of checking
1329 // type traits.
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001330 if (!AccessCheckingSFINAE && !getLangOpts().CPlusPlus11)
Richard Smith38c0e042011-10-19 00:07:01 +00001331 break;
1332
Daniel Dunbard671ab92012-03-14 09:49:32 +00001333 SourceLocation Loc = Diags.getCurrentDiagLoc();
Richard Smith38c0e042011-10-19 00:07:01 +00001334
1335 // Suppress this diagnostic.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001336 ++NumSFINAEErrors;
Richard Smith9ca64612012-05-07 09:03:25 +00001337
1338 // Make a copy of this suppressed diagnostic and store it with the
1339 // template-deduction information.
1340 if (*Info && !(*Info)->hasSFINAEDiagnostic()) {
1341 Diagnostic DiagInfo(&Diags);
1342 (*Info)->addSFINAEDiagnostic(DiagInfo.getLocation(),
1343 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1344 }
1345
Dmitri Gribenko20f45ed2019-09-12 12:16:43 +00001346 Diags.setLastDiagnosticIgnored(true);
Daniel Dunbard671ab92012-03-14 09:49:32 +00001347 Diags.Clear();
Richard Smith38c0e042011-10-19 00:07:01 +00001348
1349 // Now the diagnostic state is clear, produce a C++98 compatibility
1350 // warning.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001351 Diag(Loc, diag::warn_cxx98_compat_sfinae_access_control);
Richard Smith38c0e042011-10-19 00:07:01 +00001352
1353 // The last diagnostic which Sema produced was ignored. Suppress any
1354 // notes attached to it.
Dmitri Gribenko20f45ed2019-09-12 12:16:43 +00001355 Diags.setLastDiagnosticIgnored(true);
Richard Smith38c0e042011-10-19 00:07:01 +00001356 return;
1357 }
1358
Argyrios Kyrtzidisd0040642010-11-18 20:06:41 +00001359 case DiagnosticIDs::SFINAE_Suppress:
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001360 // Make a copy of this suppressed diagnostic and store it with the
1361 // template-deduction information;
Richard Smith9ca64612012-05-07 09:03:25 +00001362 if (*Info) {
1363 Diagnostic DiagInfo(&Diags);
Douglas Gregoredb76852011-01-27 22:31:44 +00001364 (*Info)->addSuppressedDiagnostic(DiagInfo.getLocation(),
Richard Smith9ca64612012-05-07 09:03:25 +00001365 PartialDiagnostic(DiagInfo, Context.getDiagAllocator()));
1366 }
1367
1368 // Suppress this diagnostic.
Dmitri Gribenko20f45ed2019-09-12 12:16:43 +00001369 Diags.setLastDiagnosticIgnored(true);
Daniel Dunbard671ab92012-03-14 09:49:32 +00001370 Diags.Clear();
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001371 return;
1372 }
1373 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001374
Joel E. Denny7bcc2102018-05-14 18:41:44 +00001375 // Copy the diagnostic printing policy over the ASTContext printing policy.
1376 // TODO: Stop doing that. See: https://reviews.llvm.org/D45093#1090292
Daniel Dunbard671ab92012-03-14 09:49:32 +00001377 Context.setPrintingPolicy(getPrintingPolicy());
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001378
Douglas Gregor5bb5e4a2010-10-12 23:32:35 +00001379 // Emit the diagnostic.
Daniel Dunbard671ab92012-03-14 09:49:32 +00001380 if (!Diags.EmitCurrentDiagnostic())
Douglas Gregor33834512009-06-14 07:33:30 +00001381 return;
Mike Stump11289f42009-09-09 15:08:12 +00001382
Douglas Gregorda17bd32009-03-20 22:48:49 +00001383 // If this is not a note, and we're in a template instantiation
1384 // that is different from the last template instantiation where
1385 // we emitted an error, print a template instantiation
1386 // backtrace.
Richard Smith51ec0cf2017-02-21 01:17:38 +00001387 if (!DiagnosticIDs::isBuiltinNote(DiagID))
1388 PrintContextStack();
Douglas Gregorda17bd32009-03-20 22:48:49 +00001389}
Douglas Gregorc6d5edd2009-07-02 17:08:52 +00001390
Anders Carlssonf68079e2009-08-26 22:33:56 +00001391Sema::SemaDiagnosticBuilder
1392Sema::Diag(SourceLocation Loc, const PartialDiagnostic& PD) {
1393 SemaDiagnosticBuilder Builder(Diag(Loc, PD.getDiagID()));
1394 PD.Emit(Builder);
Mike Stump11289f42009-09-09 15:08:12 +00001395
Anders Carlssonf68079e2009-08-26 22:33:56 +00001396 return Builder;
1397}
1398
Alexey Bataev89721332019-02-07 19:46:42 +00001399// Print notes showing how we can reach FD starting from an a priori
1400// known-callable function.
1401static void emitCallStackNotes(Sema &S, FunctionDecl *FD) {
1402 auto FnIt = S.DeviceKnownEmittedFns.find(FD);
1403 while (FnIt != S.DeviceKnownEmittedFns.end()) {
1404 DiagnosticBuilder Builder(
1405 S.Diags.Report(FnIt->second.Loc, diag::note_called_by));
1406 Builder << FnIt->second.FD;
1407 Builder.setForceEmit();
1408
1409 FnIt = S.DeviceKnownEmittedFns.find(FnIt->second.FD);
1410 }
1411}
1412
1413// Emit any deferred diagnostics for FD and erase them from the map in which
1414// they're stored.
Alexey Bataev9fd495b2019-08-20 19:50:13 +00001415static void emitDeferredDiags(Sema &S, FunctionDecl *FD, bool ShowCallStack) {
Alexey Bataev89721332019-02-07 19:46:42 +00001416 auto It = S.DeviceDeferredDiags.find(FD);
1417 if (It == S.DeviceDeferredDiags.end())
1418 return;
1419 bool HasWarningOrError = false;
1420 for (PartialDiagnosticAt &PDAt : It->second) {
1421 const SourceLocation &Loc = PDAt.first;
1422 const PartialDiagnostic &PD = PDAt.second;
1423 HasWarningOrError |= S.getDiagnostics().getDiagnosticLevel(
1424 PD.getDiagID(), Loc) >= DiagnosticsEngine::Warning;
1425 DiagnosticBuilder Builder(S.Diags.Report(Loc, PD.getDiagID()));
1426 Builder.setForceEmit();
1427 PD.Emit(Builder);
1428 }
1429 S.DeviceDeferredDiags.erase(It);
1430
1431 // FIXME: Should this be called after every warning/error emitted in the loop
1432 // above, instead of just once per function? That would be consistent with
1433 // how we handle immediate errors, but it also seems like a bit much.
Alexey Bataev9fd495b2019-08-20 19:50:13 +00001434 if (HasWarningOrError && ShowCallStack)
Alexey Bataev89721332019-02-07 19:46:42 +00001435 emitCallStackNotes(S, FD);
1436}
1437
1438// In CUDA, there are some constructs which may appear in semantically-valid
1439// code, but trigger errors if we ever generate code for the function in which
1440// they appear. Essentially every construct you're not allowed to use on the
1441// device falls into this category, because you are allowed to use these
1442// constructs in a __host__ __device__ function, but only if that function is
1443// never codegen'ed on the device.
1444//
1445// To handle semantic checking for these constructs, we keep track of the set of
1446// functions we know will be emitted, either because we could tell a priori that
1447// they would be emitted, or because they were transitively called by a
1448// known-emitted function.
1449//
1450// We also keep a partial call graph of which not-known-emitted functions call
1451// which other not-known-emitted functions.
1452//
1453// When we see something which is illegal if the current function is emitted
1454// (usually by way of CUDADiagIfDeviceCode, CUDADiagIfHostCode, or
1455// CheckCUDACall), we first check if the current function is known-emitted. If
1456// so, we immediately output the diagnostic.
1457//
1458// Otherwise, we "defer" the diagnostic. It sits in Sema::DeviceDeferredDiags
1459// until we discover that the function is known-emitted, at which point we take
1460// it out of this map and emit the diagnostic.
1461
1462Sema::DeviceDiagBuilder::DeviceDiagBuilder(Kind K, SourceLocation Loc,
1463 unsigned DiagID, FunctionDecl *Fn,
1464 Sema &S)
1465 : S(S), Loc(Loc), DiagID(DiagID), Fn(Fn),
1466 ShowCallStack(K == K_ImmediateWithCallStack || K == K_Deferred) {
1467 switch (K) {
1468 case K_Nop:
1469 break;
1470 case K_Immediate:
1471 case K_ImmediateWithCallStack:
1472 ImmediateDiag.emplace(S.Diag(Loc, DiagID));
1473 break;
1474 case K_Deferred:
1475 assert(Fn && "Must have a function to attach the deferred diag to.");
Alexey Bataev3167b302019-02-22 14:42:48 +00001476 auto &Diags = S.DeviceDeferredDiags[Fn];
1477 PartialDiagId.emplace(Diags.size());
1478 Diags.emplace_back(Loc, S.PDiag(DiagID));
Alexey Bataev89721332019-02-07 19:46:42 +00001479 break;
1480 }
1481}
1482
Alexey Bataeve69f94e2019-02-22 20:36:10 +00001483Sema::DeviceDiagBuilder::DeviceDiagBuilder(DeviceDiagBuilder &&D)
1484 : S(D.S), Loc(D.Loc), DiagID(D.DiagID), Fn(D.Fn),
1485 ShowCallStack(D.ShowCallStack), ImmediateDiag(D.ImmediateDiag),
1486 PartialDiagId(D.PartialDiagId) {
1487 // Clean the previous diagnostics.
1488 D.ShowCallStack = false;
1489 D.ImmediateDiag.reset();
1490 D.PartialDiagId.reset();
1491}
1492
Alexey Bataev89721332019-02-07 19:46:42 +00001493Sema::DeviceDiagBuilder::~DeviceDiagBuilder() {
1494 if (ImmediateDiag) {
1495 // Emit our diagnostic and, if it was a warning or error, output a callstack
1496 // if Fn isn't a priori known-emitted.
1497 bool IsWarningOrError = S.getDiagnostics().getDiagnosticLevel(
1498 DiagID, Loc) >= DiagnosticsEngine::Warning;
1499 ImmediateDiag.reset(); // Emit the immediate diag.
1500 if (IsWarningOrError && ShowCallStack)
1501 emitCallStackNotes(S, Fn);
Alexey Bataev3167b302019-02-22 14:42:48 +00001502 } else {
1503 assert((!PartialDiagId || ShowCallStack) &&
1504 "Must always show call stack for deferred diags.");
Alexey Bataev89721332019-02-07 19:46:42 +00001505 }
1506}
1507
1508// Indicate that this function (and thus everything it transtively calls) will
1509// be codegen'ed, and emit any deferred diagnostics on this function and its
1510// (transitive) callees.
1511void Sema::markKnownEmitted(
1512 Sema &S, FunctionDecl *OrigCaller, FunctionDecl *OrigCallee,
1513 SourceLocation OrigLoc,
1514 const llvm::function_ref<bool(Sema &, FunctionDecl *)> IsKnownEmitted) {
1515 // Nothing to do if we already know that FD is emitted.
1516 if (IsKnownEmitted(S, OrigCallee)) {
1517 assert(!S.DeviceCallGraph.count(OrigCallee));
1518 return;
1519 }
1520
1521 // We've just discovered that OrigCallee is known-emitted. Walk our call
1522 // graph to see what else we can now discover also must be emitted.
1523
1524 struct CallInfo {
1525 FunctionDecl *Caller;
1526 FunctionDecl *Callee;
1527 SourceLocation Loc;
1528 };
1529 llvm::SmallVector<CallInfo, 4> Worklist = {{OrigCaller, OrigCallee, OrigLoc}};
1530 llvm::SmallSet<CanonicalDeclPtr<FunctionDecl>, 4> Seen;
1531 Seen.insert(OrigCallee);
1532 while (!Worklist.empty()) {
1533 CallInfo C = Worklist.pop_back_val();
1534 assert(!IsKnownEmitted(S, C.Callee) &&
1535 "Worklist should not contain known-emitted functions.");
1536 S.DeviceKnownEmittedFns[C.Callee] = {C.Caller, C.Loc};
Alexey Bataev9fd495b2019-08-20 19:50:13 +00001537 emitDeferredDiags(S, C.Callee, C.Caller);
Alexey Bataev89721332019-02-07 19:46:42 +00001538
1539 // If this is a template instantiation, explore its callgraph as well:
1540 // Non-dependent calls are part of the template's callgraph, while dependent
1541 // calls are part of to the instantiation's call graph.
1542 if (auto *Templ = C.Callee->getPrimaryTemplate()) {
1543 FunctionDecl *TemplFD = Templ->getAsFunction();
1544 if (!Seen.count(TemplFD) && !S.DeviceKnownEmittedFns.count(TemplFD)) {
1545 Seen.insert(TemplFD);
1546 Worklist.push_back(
1547 {/* Caller = */ C.Caller, /* Callee = */ TemplFD, C.Loc});
1548 }
1549 }
1550
1551 // Add all functions called by Callee to our worklist.
1552 auto CGIt = S.DeviceCallGraph.find(C.Callee);
1553 if (CGIt == S.DeviceCallGraph.end())
1554 continue;
1555
1556 for (std::pair<CanonicalDeclPtr<FunctionDecl>, SourceLocation> FDLoc :
1557 CGIt->second) {
1558 FunctionDecl *NewCallee = FDLoc.first;
1559 SourceLocation CallLoc = FDLoc.second;
1560 if (Seen.count(NewCallee) || IsKnownEmitted(S, NewCallee))
1561 continue;
1562 Seen.insert(NewCallee);
1563 Worklist.push_back(
1564 {/* Caller = */ C.Callee, /* Callee = */ NewCallee, CallLoc});
1565 }
1566
1567 // C.Callee is now known-emitted, so we no longer need to maintain its list
1568 // of callees in DeviceCallGraph.
1569 S.DeviceCallGraph.erase(CGIt);
1570 }
1571}
1572
Alexey Bataev3167b302019-02-22 14:42:48 +00001573Sema::DeviceDiagBuilder Sema::targetDiag(SourceLocation Loc, unsigned DiagID) {
Alexey Bataev729e2422019-08-23 16:11:14 +00001574 if (LangOpts.OpenMP)
1575 return LangOpts.OpenMPIsDevice ? diagIfOpenMPDeviceCode(Loc, DiagID)
1576 : diagIfOpenMPHostCode(Loc, DiagID);
Alexey Bataev3167b302019-02-22 14:42:48 +00001577 if (getLangOpts().CUDA)
1578 return getLangOpts().CUDAIsDevice ? CUDADiagIfDeviceCode(Loc, DiagID)
1579 : CUDADiagIfHostCode(Loc, DiagID);
Alexey Bataev5c96c1c2019-02-20 17:42:57 +00001580 return DeviceDiagBuilder(DeviceDiagBuilder::K_Immediate, Loc, DiagID,
1581 getCurFunctionDecl(), *this);
1582}
1583
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001584/// Looks through the macro-expansion chain for the given
Chandler Carruthc22845a2011-07-26 05:40:03 +00001585/// location, looking for a macro expansion with the given name.
John McCall462c0552011-03-08 07:59:04 +00001586/// If one is found, returns true and sets the location to that
Chandler Carruthc22845a2011-07-26 05:40:03 +00001587/// expansion loc.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001588bool Sema::findMacroSpelling(SourceLocation &locref, StringRef name) {
John McCall462c0552011-03-08 07:59:04 +00001589 SourceLocation loc = locref;
1590 if (!loc.isMacroID()) return false;
1591
1592 // There's no good way right now to look at the intermediate
Chandler Carruthc22845a2011-07-26 05:40:03 +00001593 // expansions, so just jump to the expansion location.
Chandler Carruth35f53202011-07-25 16:49:02 +00001594 loc = getSourceManager().getExpansionLoc(loc);
John McCall462c0552011-03-08 07:59:04 +00001595
1596 // If that's written with the name, stop here.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001597 SmallVector<char, 16> buffer;
John McCall462c0552011-03-08 07:59:04 +00001598 if (getPreprocessor().getSpelling(loc, buffer) == name) {
1599 locref = loc;
1600 return true;
1601 }
1602 return false;
1603}
1604
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001605/// Determines the active Scope associated with the given declaration
Douglas Gregor0be31a22010-07-02 17:43:08 +00001606/// context.
1607///
1608/// This routine maps a declaration context to the active Scope object that
1609/// represents that declaration context in the parser. It is typically used
1610/// from "scope-less" code (e.g., template instantiation, lazy creation of
1611/// declarations) that injects a name for name-lookup purposes and, therefore,
1612/// must update the Scope.
1613///
1614/// \returns The scope corresponding to the given declaraion context, or NULL
1615/// if no such scope is open.
1616Scope *Sema::getScopeForContext(DeclContext *Ctx) {
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001617
Douglas Gregor0be31a22010-07-02 17:43:08 +00001618 if (!Ctx)
Craig Topperc3ec1492014-05-26 06:22:03 +00001619 return nullptr;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001620
Douglas Gregor0be31a22010-07-02 17:43:08 +00001621 Ctx = Ctx->getPrimaryContext();
1622 for (Scope *S = getCurScope(); S; S = S->getParent()) {
Sebastian Redlcaef9ab2010-07-08 23:07:34 +00001623 // Ignore scopes that cannot have declarations. This is important for
1624 // out-of-line definitions of static class members.
1625 if (S->getFlags() & (Scope::DeclScope | Scope::TemplateParamScope))
Ted Kremenekc37877d2013-10-08 17:08:03 +00001626 if (DeclContext *Entity = S->getEntity())
Sebastian Redlcaef9ab2010-07-08 23:07:34 +00001627 if (Ctx == Entity->getPrimaryContext())
1628 return S;
Douglas Gregor0be31a22010-07-02 17:43:08 +00001629 }
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001630
Craig Topperc3ec1492014-05-26 06:22:03 +00001631 return nullptr;
Douglas Gregor0be31a22010-07-02 17:43:08 +00001632}
Douglas Gregor9a28e842010-03-01 23:15:13 +00001633
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001634/// Enter a new function scope
Douglas Gregor9a28e842010-03-01 23:15:13 +00001635void Sema::PushFunctionScope() {
Richard Smith2fdd95c2019-05-31 00:45:09 +00001636 if (FunctionScopes.empty() && CachedFunctionScope) {
1637 // Use CachedFunctionScope to avoid allocating memory when possible.
1638 CachedFunctionScope->Clear();
1639 FunctionScopes.push_back(CachedFunctionScope.release());
Reid Kleckner87a31802018-03-12 21:43:02 +00001640 } else {
1641 FunctionScopes.push_back(new FunctionScopeInfo(getDiagnostics()));
Douglas Gregor9a28e842010-03-01 23:15:13 +00001642 }
Alexey Bataev4b465392017-04-26 15:06:24 +00001643 if (LangOpts.OpenMP)
1644 pushOpenMPFunctionRegion();
Douglas Gregor9a28e842010-03-01 23:15:13 +00001645}
1646
1647void Sema::PushBlockScope(Scope *BlockScope, BlockDecl *Block) {
Argyrios Kyrtzidisf51ec1d2010-11-19 00:19:15 +00001648 FunctionScopes.push_back(new BlockScopeInfo(getDiagnostics(),
Douglas Gregor9a28e842010-03-01 23:15:13 +00001649 BlockScope, Block));
1650}
1651
Faisal Vali97d8c332013-11-12 01:46:33 +00001652LambdaScopeInfo *Sema::PushLambdaScope() {
Faisal Vali524ca282013-11-12 01:40:44 +00001653 LambdaScopeInfo *const LSI = new LambdaScopeInfo(getDiagnostics());
1654 FunctionScopes.push_back(LSI);
1655 return LSI;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001656}
1657
1658void Sema::RecordParsingTemplateParameterDepth(unsigned Depth) {
1659 if (LambdaScopeInfo *const LSI = getCurLambda()) {
1660 LSI->AutoTemplateParameterDepth = Depth;
1661 return;
Reid Kleckner87a31802018-03-12 21:43:02 +00001662 }
1663 llvm_unreachable(
Faisal Vali2b391ab2013-09-26 19:54:12 +00001664 "Remove assertion if intentionally called in a non-lambda context.");
Eli Friedman71c80552012-01-05 03:35:19 +00001665}
1666
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001667// Check that the type of the VarDecl has an accessible copy constructor and
JF Bastienea51a8c2019-04-30 00:19:43 +00001668// resolve its destructor's exception specification.
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001669static void checkEscapingByref(VarDecl *VD, Sema &S) {
1670 QualType T = VD->getType();
1671 EnterExpressionEvaluationContext scope(
1672 S, Sema::ExpressionEvaluationContext::PotentiallyEvaluated);
1673 SourceLocation Loc = VD->getLocation();
Bruno Ricci5fc4db72018-12-21 14:10:18 +00001674 Expr *VarRef =
1675 new (S.Context) DeclRefExpr(S.Context, VD, false, T, VK_LValue, Loc);
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001676 ExprResult Result = S.PerformMoveOrCopyInitialization(
1677 InitializedEntity::InitializeBlock(Loc, T, false), VD, VD->getType(),
1678 VarRef, /*AllowNRVO=*/true);
1679 if (!Result.isInvalid()) {
1680 Result = S.MaybeCreateExprWithCleanups(Result);
1681 Expr *Init = Result.getAs<Expr>();
1682 S.Context.setBlockVarCopyInit(VD, Init, S.canThrow(Init));
1683 }
1684
JF Bastienea51a8c2019-04-30 00:19:43 +00001685 // The destructor's exception specification is needed when IRGen generates
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001686 // block copy/destroy functions. Resolve it here.
1687 if (const CXXRecordDecl *RD = T->getAsCXXRecordDecl())
1688 if (CXXDestructorDecl *DD = RD->getDestructor()) {
1689 auto *FPT = DD->getType()->getAs<FunctionProtoType>();
1690 S.ResolveExceptionSpec(Loc, FPT);
1691 }
1692}
1693
1694static void markEscapingByrefs(const FunctionScopeInfo &FSI, Sema &S) {
1695 // Set the EscapingByref flag of __block variables captured by
1696 // escaping blocks.
1697 for (const BlockDecl *BD : FSI.Blocks) {
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001698 for (const BlockDecl::Capture &BC : BD->captures()) {
1699 VarDecl *VD = BC.getVariable();
Akira Hatanaka09051062019-09-07 00:34:43 +00001700 if (VD->hasAttr<BlocksAttr>()) {
1701 // Nothing to do if this is a __block variable captured by a
1702 // non-escaping block.
1703 if (BD->doesNotEscape())
1704 continue;
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001705 VD->setEscapingByref();
Akira Hatanaka09051062019-09-07 00:34:43 +00001706 }
1707 // Check whether the captured variable is or contains an object of
1708 // non-trivial C union type.
1709 QualType CapType = BC.getVariable()->getType();
1710 if (CapType.hasNonTrivialToPrimitiveDestructCUnion() ||
1711 CapType.hasNonTrivialToPrimitiveCopyCUnion())
1712 S.checkNonTrivialCUnion(BC.getVariable()->getType(),
1713 BD->getCaretLocation(),
1714 Sema::NTCUC_BlockCapture,
1715 Sema::NTCUK_Destruct|Sema::NTCUK_Copy);
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001716 }
1717 }
1718
1719 for (VarDecl *VD : FSI.ByrefBlockVars) {
1720 // __block variables might require us to capture a copy-initializer.
1721 if (!VD->isEscapingByref())
1722 continue;
1723 // It's currently invalid to ever have a __block variable with an
1724 // array type; should we diagnose that here?
1725 // Regardless, we don't want to ignore array nesting when
1726 // constructing this copy.
1727 if (VD->getType()->isStructureOrClassType())
1728 checkEscapingByref(VD, S);
1729 }
1730}
1731
Richard Smith2fdd95c2019-05-31 00:45:09 +00001732/// Pop a function (or block or lambda or captured region) scope from the stack.
1733///
1734/// \param WP The warning policy to use for CFG-based warnings, or null if such
1735/// warnings should not be produced.
1736/// \param D The declaration corresponding to this function scope, if producing
1737/// CFG-based warnings.
1738/// \param BlockType The type of the block expression, if D is a BlockDecl.
1739Sema::PoppedFunctionScopePtr
1740Sema::PopFunctionScopeInfo(const AnalysisBasedWarnings::Policy *WP,
1741 const Decl *D, QualType BlockType) {
Reid Kleckner8d485b82018-03-08 01:12:22 +00001742 assert(!FunctionScopes.empty() && "mismatched push/pop!");
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001743
Akira Hatanaka8e57b072018-10-01 21:51:28 +00001744 markEscapingByrefs(*FunctionScopes.back(), *this);
1745
Richard Smith2fdd95c2019-05-31 00:45:09 +00001746 PoppedFunctionScopePtr Scope(FunctionScopes.pop_back_val(),
1747 PoppedFunctionScopeDeleter(this));
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001748
Alexey Bataev4b465392017-04-26 15:06:24 +00001749 if (LangOpts.OpenMP)
Richard Smith2fdd95c2019-05-31 00:45:09 +00001750 popOpenMPFunctionRegion(Scope.get());
Alexey Bataev4b465392017-04-26 15:06:24 +00001751
Ted Kremenek1767a272011-02-23 01:51:48 +00001752 // Issue any analysis-based warnings.
1753 if (WP && D)
Richard Smith2fdd95c2019-05-31 00:45:09 +00001754 AnalysisWarnings.IssueWarnings(*WP, Scope.get(), D, BlockType);
Aaron Ballman130a3b02014-05-15 20:58:55 +00001755 else
1756 for (const auto &PUD : Scope->PossiblyUnreachableDiags)
1757 Diag(PUD.Loc, PUD.PD);
Ted Kremenek1767a272011-02-23 01:51:48 +00001758
Richard Smith2fdd95c2019-05-31 00:45:09 +00001759 return Scope;
1760}
1761
1762void Sema::PoppedFunctionScopeDeleter::
1763operator()(sema::FunctionScopeInfo *Scope) const {
1764 // Stash the function scope for later reuse if it's for a normal function.
1765 if (Scope->isPlainFunction() && !Self->CachedFunctionScope)
1766 Self->CachedFunctionScope.reset(Scope);
1767 else
John McCallaab3e412010-08-25 08:40:02 +00001768 delete Scope;
Douglas Gregor9a28e842010-03-01 23:15:13 +00001769}
1770
Richard Smith6eb9b9e2018-02-03 00:44:57 +00001771void Sema::PushCompoundScope(bool IsStmtExpr) {
1772 getCurFunction()->CompoundScopes.push_back(CompoundScopeInfo(IsStmtExpr));
Dmitri Gribenko800ddf32012-02-14 22:14:32 +00001773}
1774
1775void Sema::PopCompoundScope() {
1776 FunctionScopeInfo *CurFunction = getCurFunction();
1777 assert(!CurFunction->CompoundScopes.empty() && "mismatched push/pop");
1778
1779 CurFunction->CompoundScopes.pop_back();
1780}
1781
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001782/// Determine whether any errors occurred within this function/method/
Douglas Gregor9a28e842010-03-01 23:15:13 +00001783/// block.
John McCall31168b02011-06-15 23:02:42 +00001784bool Sema::hasAnyUnrecoverableErrorsInThisFunction() const {
1785 return getCurFunction()->ErrorTrap.hasUnrecoverableErrorOccurred();
Douglas Gregor9a28e842010-03-01 23:15:13 +00001786}
1787
Reid Kleckner87a31802018-03-12 21:43:02 +00001788void Sema::setFunctionHasBranchIntoScope() {
1789 if (!FunctionScopes.empty())
1790 FunctionScopes.back()->setHasBranchIntoScope();
1791}
1792
1793void Sema::setFunctionHasBranchProtectedScope() {
1794 if (!FunctionScopes.empty())
1795 FunctionScopes.back()->setHasBranchProtectedScope();
1796}
1797
1798void Sema::setFunctionHasIndirectGoto() {
1799 if (!FunctionScopes.empty())
1800 FunctionScopes.back()->setHasIndirectGoto();
1801}
1802
Douglas Gregor9a28e842010-03-01 23:15:13 +00001803BlockScopeInfo *Sema::getCurBlock() {
1804 if (FunctionScopes.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00001805 return nullptr;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001806
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001807 auto CurBSI = dyn_cast<BlockScopeInfo>(FunctionScopes.back());
1808 if (CurBSI && CurBSI->TheDecl &&
1809 !CurBSI->TheDecl->Encloses(CurContext)) {
1810 // We have switched contexts due to template instantiation.
Richard Smith696e3122017-02-23 01:43:54 +00001811 assert(!CodeSynthesisContexts.empty());
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001812 return nullptr;
1813 }
1814
1815 return CurBSI;
Douglas Gregor9a28e842010-03-01 23:15:13 +00001816}
John McCall75b960e2010-06-01 09:23:16 +00001817
Reid Kleckner04f9bca2018-03-07 22:48:35 +00001818FunctionScopeInfo *Sema::getEnclosingFunction() const {
1819 if (FunctionScopes.empty())
1820 return nullptr;
1821
1822 for (int e = FunctionScopes.size() - 1; e >= 0; --e) {
1823 if (isa<sema::BlockScopeInfo>(FunctionScopes[e]))
1824 continue;
1825 return FunctionScopes[e];
1826 }
1827 return nullptr;
1828}
1829
Richard Smithb26bc342019-08-26 22:51:28 +00001830LambdaScopeInfo *Sema::getEnclosingLambda() const {
1831 for (auto *Scope : llvm::reverse(FunctionScopes)) {
1832 if (auto *LSI = dyn_cast<sema::LambdaScopeInfo>(Scope)) {
1833 if (LSI->Lambda && !LSI->Lambda->Encloses(CurContext)) {
1834 // We have switched contexts due to template instantiation.
1835 // FIXME: We should swap out the FunctionScopes during code synthesis
1836 // so that we don't need to check for this.
1837 assert(!CodeSynthesisContexts.empty());
1838 return nullptr;
1839 }
1840 return LSI;
1841 }
1842 }
1843 return nullptr;
1844}
1845
Akira Hatanaka7cbbb882017-03-01 06:11:25 +00001846LambdaScopeInfo *Sema::getCurLambda(bool IgnoreNonLambdaCapturingScope) {
Eli Friedman4817cf72012-01-06 03:05:34 +00001847 if (FunctionScopes.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00001848 return nullptr;
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001849
Alexey Bataev31939e32016-11-11 12:36:20 +00001850 auto I = FunctionScopes.rbegin();
Akira Hatanaka7cbbb882017-03-01 06:11:25 +00001851 if (IgnoreNonLambdaCapturingScope) {
Alexey Bataev31939e32016-11-11 12:36:20 +00001852 auto E = FunctionScopes.rend();
Akira Hatanaka7cbbb882017-03-01 06:11:25 +00001853 while (I != E && isa<CapturingScopeInfo>(*I) && !isa<LambdaScopeInfo>(*I))
Alexey Bataev31939e32016-11-11 12:36:20 +00001854 ++I;
1855 if (I == E)
1856 return nullptr;
1857 }
1858 auto *CurLSI = dyn_cast<LambdaScopeInfo>(*I);
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001859 if (CurLSI && CurLSI->Lambda &&
1860 !CurLSI->Lambda->Encloses(CurContext)) {
1861 // We have switched contexts due to template instantiation.
Richard Smith696e3122017-02-23 01:43:54 +00001862 assert(!CodeSynthesisContexts.empty());
Argyrios Kyrtzidisea75aad2014-04-26 18:29:13 +00001863 return nullptr;
1864 }
1865
1866 return CurLSI;
Eli Friedman4817cf72012-01-06 03:05:34 +00001867}
Richard Smithb26bc342019-08-26 22:51:28 +00001868
Fangrui Song6907ce22018-07-30 19:24:48 +00001869// We have a generic lambda if we parsed auto parameters, or we have
Faisal Vali2b391ab2013-09-26 19:54:12 +00001870// an associated template parameter list.
1871LambdaScopeInfo *Sema::getCurGenericLambda() {
1872 if (LambdaScopeInfo *LSI = getCurLambda()) {
Hamza Sood8205a812019-05-04 10:49:46 +00001873 return (LSI->TemplateParams.size() ||
Craig Topperc3ec1492014-05-26 06:22:03 +00001874 LSI->GLTemplateParameterList) ? LSI : nullptr;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001875 }
Craig Topperc3ec1492014-05-26 06:22:03 +00001876 return nullptr;
Faisal Vali2b391ab2013-09-26 19:54:12 +00001877}
1878
Eli Friedman4817cf72012-01-06 03:05:34 +00001879
Dmitri Gribenkoaab83832012-06-20 00:34:58 +00001880void Sema::ActOnComment(SourceRange Comment) {
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00001881 if (!LangOpts.RetainCommentsFromSystemHeaders &&
1882 SourceMgr.isInSystemHeader(Comment.getBegin()))
1883 return;
David L. Jones13d5a872018-03-02 00:07:45 +00001884 RawComment RC(SourceMgr, Comment, LangOpts.CommentOpts, false);
Dmitri Gribenko052f60d2012-06-22 16:02:55 +00001885 if (RC.isAlmostTrailingComment()) {
1886 SourceRange MagicMarkerRange(Comment.getBegin(),
1887 Comment.getBegin().getLocWithOffset(3));
1888 StringRef MagicMarkerText;
1889 switch (RC.getKind()) {
Abramo Bagnarae06a8882012-07-04 07:30:26 +00001890 case RawComment::RCK_OrdinaryBCPL:
Dmitri Gribenko052f60d2012-06-22 16:02:55 +00001891 MagicMarkerText = "///<";
1892 break;
Abramo Bagnarae06a8882012-07-04 07:30:26 +00001893 case RawComment::RCK_OrdinaryC:
Dmitri Gribenko052f60d2012-06-22 16:02:55 +00001894 MagicMarkerText = "/**<";
1895 break;
1896 default:
1897 llvm_unreachable("if this is an almost Doxygen comment, "
1898 "it should be ordinary");
1899 }
1900 Diag(Comment.getBegin(), diag::warn_not_a_doxygen_trailing_member_comment) <<
1901 FixItHint::CreateReplacement(MagicMarkerRange, MagicMarkerText);
1902 }
Dmitri Gribenkoaab83832012-06-20 00:34:58 +00001903 Context.addComment(RC);
1904}
1905
John McCall75b960e2010-06-01 09:23:16 +00001906// Pin this vtable to this file.
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +00001907ExternalSemaSource::~ExternalSemaSource() {}
John McCallfaf5fb42010-08-26 23:41:50 +00001908
Douglas Gregore1716012012-01-25 00:49:42 +00001909void ExternalSemaSource::ReadMethodPool(Selector Sel) { }
Manman Rena0f31a02016-04-29 19:04:05 +00001910void ExternalSemaSource::updateOutOfDateSelector(Selector Sel) { }
Sebastian Redlc1ca90a2010-09-28 20:23:00 +00001911
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001912void ExternalSemaSource::ReadKnownNamespaces(
Michael Gottesmanbf0fd392013-01-20 01:04:14 +00001913 SmallVectorImpl<NamespaceDecl *> &Namespaces) {
Douglas Gregorc2fa1692011-06-28 16:20:02 +00001914}
1915
Nick Lewycky9c7eb1d2013-02-01 08:13:20 +00001916void ExternalSemaSource::ReadUndefinedButUsed(
Richard Smithd6a04d72016-03-25 21:49:43 +00001917 llvm::MapVector<NamedDecl *, SourceLocation> &Undefined) {}
Nick Lewycky8334af82013-01-26 00:35:08 +00001918
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00001919void ExternalSemaSource::ReadMismatchingDeleteExpressions(llvm::MapVector<
1920 FieldDecl *, llvm::SmallVector<std::pair<SourceLocation, bool>, 4>> &) {}
1921
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00001922/// Figure out if an expression could be turned into a call.
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001923///
1924/// Use this when trying to recover from an error where the programmer may have
1925/// written just the name of a function instead of actually calling it.
1926///
1927/// \param E - The expression to examine.
1928/// \param ZeroArgCallReturnTy - If the expression can be turned into a call
1929/// with no arguments, this parameter is set to the type returned by such a
1930/// call; otherwise, it is set to an empty QualType.
John McCall50a2c2c2011-10-11 23:14:30 +00001931/// \param OverloadSet - If the expression is an overloaded function
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001932/// name, this parameter is populated with the decls of the various overloads.
David Blaikiee5323aa2013-06-21 23:54:45 +00001933bool Sema::tryExprAsCall(Expr &E, QualType &ZeroArgCallReturnTy,
1934 UnresolvedSetImpl &OverloadSet) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001935 ZeroArgCallReturnTy = QualType();
John McCall50a2c2c2011-10-11 23:14:30 +00001936 OverloadSet.clear();
1937
Craig Topperc3ec1492014-05-26 06:22:03 +00001938 const OverloadExpr *Overloads = nullptr;
David Blaikiee5323aa2013-06-21 23:54:45 +00001939 bool IsMemExpr = false;
John McCall50a2c2c2011-10-11 23:14:30 +00001940 if (E.getType() == Context.OverloadTy) {
1941 OverloadExpr::FindResult FR = OverloadExpr::find(const_cast<Expr*>(&E));
John McCall50a2c2c2011-10-11 23:14:30 +00001942
David Blaikie6df859d82013-06-04 00:28:46 +00001943 // Ignore overloads that are pointer-to-member constants.
1944 if (FR.HasFormOfMemberPointer)
1945 return false;
1946
1947 Overloads = FR.Expression;
1948 } else if (E.getType() == Context.BoundMemberTy) {
1949 Overloads = dyn_cast<UnresolvedMemberExpr>(E.IgnoreParens());
David Blaikiee5323aa2013-06-21 23:54:45 +00001950 IsMemExpr = true;
David Blaikie6df859d82013-06-04 00:28:46 +00001951 }
David Blaikiee5323aa2013-06-21 23:54:45 +00001952
1953 bool Ambiguous = false;
Erich Keane3efe0022018-07-20 14:13:28 +00001954 bool IsMV = false;
David Blaikiee5323aa2013-06-21 23:54:45 +00001955
David Blaikie6df859d82013-06-04 00:28:46 +00001956 if (Overloads) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001957 for (OverloadExpr::decls_iterator it = Overloads->decls_begin(),
1958 DeclsEnd = Overloads->decls_end(); it != DeclsEnd; ++it) {
John McCall50a2c2c2011-10-11 23:14:30 +00001959 OverloadSet.addDecl(*it);
1960
David Blaikiee5323aa2013-06-21 23:54:45 +00001961 // Check whether the function is a non-template, non-member which takes no
John McCall50a2c2c2011-10-11 23:14:30 +00001962 // arguments.
David Blaikiee5323aa2013-06-21 23:54:45 +00001963 if (IsMemExpr)
1964 continue;
John McCall50a2c2c2011-10-11 23:14:30 +00001965 if (const FunctionDecl *OverloadDecl
1966 = dyn_cast<FunctionDecl>((*it)->getUnderlyingDecl())) {
David Blaikie6df859d82013-06-04 00:28:46 +00001967 if (OverloadDecl->getMinRequiredArguments() == 0) {
Erich Keane3efe0022018-07-20 14:13:28 +00001968 if (!ZeroArgCallReturnTy.isNull() && !Ambiguous &&
1969 (!IsMV || !(OverloadDecl->isCPUDispatchMultiVersion() ||
1970 OverloadDecl->isCPUSpecificMultiVersion()))) {
David Blaikie6df859d82013-06-04 00:28:46 +00001971 ZeroArgCallReturnTy = QualType();
1972 Ambiguous = true;
Erich Keane3efe0022018-07-20 14:13:28 +00001973 } else {
Alp Toker314cc812014-01-25 16:55:45 +00001974 ZeroArgCallReturnTy = OverloadDecl->getReturnType();
Erich Keane3efe0022018-07-20 14:13:28 +00001975 IsMV = OverloadDecl->isCPUDispatchMultiVersion() ||
1976 OverloadDecl->isCPUSpecificMultiVersion();
1977 }
David Blaikie6df859d82013-06-04 00:28:46 +00001978 }
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001979 }
1980 }
John McCall50a2c2c2011-10-11 23:14:30 +00001981
David Blaikiee5323aa2013-06-21 23:54:45 +00001982 // If it's not a member, use better machinery to try to resolve the call
1983 if (!IsMemExpr)
1984 return !ZeroArgCallReturnTy.isNull();
1985 }
1986
1987 // Attempt to call the member with no arguments - this will correctly handle
1988 // member templates with defaults/deduction of template arguments, overloads
1989 // with default arguments, etc.
Eli Friedman544c9562013-07-08 23:35:04 +00001990 if (IsMemExpr && !E.isTypeDependent()) {
Richard Smith2e3ed4a2019-08-16 19:53:22 +00001991 Sema::TentativeAnalysisScope Trap(*this);
Craig Topperc3ec1492014-05-26 06:22:03 +00001992 ExprResult R = BuildCallToMemberFunction(nullptr, &E, SourceLocation(),
1993 None, SourceLocation());
David Blaikiee5323aa2013-06-21 23:54:45 +00001994 if (R.isUsable()) {
1995 ZeroArgCallReturnTy = R.get()->getType();
1996 return true;
1997 }
1998 return false;
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00001999 }
2000
John McCall50a2c2c2011-10-11 23:14:30 +00002001 if (const DeclRefExpr *DeclRef = dyn_cast<DeclRefExpr>(E.IgnoreParens())) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002002 if (const FunctionDecl *Fun = dyn_cast<FunctionDecl>(DeclRef->getDecl())) {
2003 if (Fun->getMinRequiredArguments() == 0)
Alp Toker314cc812014-01-25 16:55:45 +00002004 ZeroArgCallReturnTy = Fun->getReturnType();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002005 return true;
2006 }
2007 }
2008
2009 // We don't have an expression that's convenient to get a FunctionDecl from,
2010 // but we can at least check if the type is "function of 0 arguments".
2011 QualType ExprTy = E.getType();
Craig Topperc3ec1492014-05-26 06:22:03 +00002012 const FunctionType *FunTy = nullptr;
Matt Beaumont-Gay330a5b42011-05-05 00:59:35 +00002013 QualType PointeeTy = ExprTy->getPointeeType();
2014 if (!PointeeTy.isNull())
2015 FunTy = PointeeTy->getAs<FunctionType>();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002016 if (!FunTy)
2017 FunTy = ExprTy->getAs<FunctionType>();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002018
2019 if (const FunctionProtoType *FPT =
2020 dyn_cast_or_null<FunctionProtoType>(FunTy)) {
Alp Toker9cacbab2014-01-20 20:26:09 +00002021 if (FPT->getNumParams() == 0)
Alp Toker314cc812014-01-25 16:55:45 +00002022 ZeroArgCallReturnTy = FunTy->getReturnType();
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002023 return true;
2024 }
2025 return false;
2026}
2027
Adrian Prantl9fc8faf2018-05-09 01:00:01 +00002028/// Give notes for a set of overloads.
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002029///
David Blaikiee5323aa2013-06-21 23:54:45 +00002030/// A companion to tryExprAsCall. In cases when the name that the programmer
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002031/// wrote was an overloaded function, we may be able to make some guesses about
2032/// plausible overloads based on their return types; such guesses can be handed
2033/// off to this method to be emitted as notes.
2034///
2035/// \param Overloads - The overloads to note.
2036/// \param FinalNoteLoc - If we've suppressed printing some overloads due to
2037/// -fshow-overloads=best, this is the location to attach to the note about too
2038/// many candidates. Typically this will be the location of the original
2039/// ill-formed expression.
John McCall50a2c2c2011-10-11 23:14:30 +00002040static void noteOverloads(Sema &S, const UnresolvedSetImpl &Overloads,
2041 const SourceLocation FinalNoteLoc) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002042 int ShownOverloads = 0;
2043 int SuppressedOverloads = 0;
2044 for (UnresolvedSetImpl::iterator It = Overloads.begin(),
2045 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2046 // FIXME: Magic number for max shown overloads stolen from
2047 // OverloadCandidateSet::NoteCandidates.
Douglas Gregor79591782012-10-23 23:11:23 +00002048 if (ShownOverloads >= 4 && S.Diags.getShowOverloads() == Ovl_Best) {
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002049 ++SuppressedOverloads;
2050 continue;
2051 }
John McCall50a2c2c2011-10-11 23:14:30 +00002052
2053 NamedDecl *Fn = (*It)->getUnderlyingDecl();
Erich Keane281d20b2018-01-08 21:34:17 +00002054 // Don't print overloads for non-default multiversioned functions.
2055 if (const auto *FD = Fn->getAsFunction()) {
Erich Keane3efe0022018-07-20 14:13:28 +00002056 if (FD->isMultiVersion() && FD->hasAttr<TargetAttr>() &&
Erich Keane281d20b2018-01-08 21:34:17 +00002057 !FD->getAttr<TargetAttr>()->isDefaultVersion())
2058 continue;
2059 }
Abramo Bagnaradc1646d2011-11-15 21:43:28 +00002060 S.Diag(Fn->getLocation(), diag::note_possible_target_of_call);
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002061 ++ShownOverloads;
2062 }
John McCall50a2c2c2011-10-11 23:14:30 +00002063
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002064 if (SuppressedOverloads)
John McCall50a2c2c2011-10-11 23:14:30 +00002065 S.Diag(FinalNoteLoc, diag::note_ovl_too_many_candidates)
2066 << SuppressedOverloads;
2067}
2068
2069static void notePlausibleOverloads(Sema &S, SourceLocation Loc,
2070 const UnresolvedSetImpl &Overloads,
2071 bool (*IsPlausibleResult)(QualType)) {
2072 if (!IsPlausibleResult)
2073 return noteOverloads(S, Overloads, Loc);
2074
2075 UnresolvedSet<2> PlausibleOverloads;
2076 for (OverloadExpr::decls_iterator It = Overloads.begin(),
2077 DeclsEnd = Overloads.end(); It != DeclsEnd; ++It) {
2078 const FunctionDecl *OverloadDecl = cast<FunctionDecl>(*It);
Alp Toker314cc812014-01-25 16:55:45 +00002079 QualType OverloadResultTy = OverloadDecl->getReturnType();
John McCall50a2c2c2011-10-11 23:14:30 +00002080 if (IsPlausibleResult(OverloadResultTy))
2081 PlausibleOverloads.addDecl(It.getDecl());
2082 }
2083 noteOverloads(S, PlausibleOverloads, Loc);
2084}
2085
2086/// Determine whether the given expression can be called by just
2087/// putting parentheses after it. Notably, expressions with unary
2088/// operators can't be because the unary operator will start parsing
2089/// outside the call.
2090static bool IsCallableWithAppend(Expr *E) {
2091 E = E->IgnoreImplicit();
2092 return (!isa<CStyleCastExpr>(E) &&
2093 !isa<UnaryOperator>(E) &&
2094 !isa<BinaryOperator>(E) &&
2095 !isa<CXXOperatorCallExpr>(E));
2096}
2097
Erich Keane3efe0022018-07-20 14:13:28 +00002098static bool IsCPUDispatchCPUSpecificMultiVersion(const Expr *E) {
2099 if (const auto *UO = dyn_cast<UnaryOperator>(E))
2100 E = UO->getSubExpr();
2101
2102 if (const auto *ULE = dyn_cast<UnresolvedLookupExpr>(E)) {
2103 if (ULE->getNumDecls() == 0)
2104 return false;
2105
2106 const NamedDecl *ND = *ULE->decls_begin();
2107 if (const auto *FD = dyn_cast<FunctionDecl>(ND))
2108 return FD->isCPUDispatchMultiVersion() || FD->isCPUSpecificMultiVersion();
2109 }
2110 return false;
2111}
2112
John McCall50a2c2c2011-10-11 23:14:30 +00002113bool Sema::tryToRecoverWithCall(ExprResult &E, const PartialDiagnostic &PD,
2114 bool ForceComplain,
2115 bool (*IsPlausibleResult)(QualType)) {
2116 SourceLocation Loc = E.get()->getExprLoc();
2117 SourceRange Range = E.get()->getSourceRange();
2118
2119 QualType ZeroArgCallTy;
2120 UnresolvedSet<4> Overloads;
David Blaikiee5323aa2013-06-21 23:54:45 +00002121 if (tryExprAsCall(*E.get(), ZeroArgCallTy, Overloads) &&
John McCall50a2c2c2011-10-11 23:14:30 +00002122 !ZeroArgCallTy.isNull() &&
2123 (!IsPlausibleResult || IsPlausibleResult(ZeroArgCallTy))) {
2124 // At this point, we know E is potentially callable with 0
2125 // arguments and that it returns something of a reasonable type,
2126 // so we can emit a fixit and carry on pretending that E was
2127 // actually a CallExpr.
Craig Topper07fa1762015-11-15 02:31:46 +00002128 SourceLocation ParenInsertionLoc = getLocForEndOfToken(Range.getEnd());
Erich Keane3efe0022018-07-20 14:13:28 +00002129 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2130 Diag(Loc, PD) << /*zero-arg*/ 1 << IsMV << Range
2131 << (IsCallableWithAppend(E.get())
2132 ? FixItHint::CreateInsertion(ParenInsertionLoc, "()")
2133 : FixItHint());
2134 if (!IsMV)
2135 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
John McCall50a2c2c2011-10-11 23:14:30 +00002136
2137 // FIXME: Try this before emitting the fixit, and suppress diagnostics
2138 // while doing so.
Richard Smith255b85f2019-05-08 01:36:36 +00002139 E = BuildCallExpr(nullptr, E.get(), Range.getEnd(), None,
Nick Lewycky1e43d952013-08-21 19:09:44 +00002140 Range.getEnd().getLocWithOffset(1));
John McCall50a2c2c2011-10-11 23:14:30 +00002141 return true;
2142 }
2143
2144 if (!ForceComplain) return false;
2145
Erich Keane3efe0022018-07-20 14:13:28 +00002146 bool IsMV = IsCPUDispatchCPUSpecificMultiVersion(E.get());
2147 Diag(Loc, PD) << /*not zero-arg*/ 0 << IsMV << Range;
2148 if (!IsMV)
2149 notePlausibleOverloads(*this, Loc, Overloads, IsPlausibleResult);
John McCall50a2c2c2011-10-11 23:14:30 +00002150 E = ExprError();
2151 return true;
Matt Beaumont-Gay3c273912011-05-04 22:10:40 +00002152}
Argyrios Kyrtzidis3e56dd42013-03-14 22:56:43 +00002153
2154IdentifierInfo *Sema::getSuperIdentifier() const {
2155 if (!Ident_super)
2156 Ident_super = &Context.Idents.get("super");
2157 return Ident_super;
2158}
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002159
Nico Webere1687c52013-06-20 21:44:55 +00002160IdentifierInfo *Sema::getFloat128Identifier() const {
2161 if (!Ident___float128)
2162 Ident___float128 = &Context.Idents.get("__float128");
2163 return Ident___float128;
2164}
2165
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002166void Sema::PushCapturedRegionScope(Scope *S, CapturedDecl *CD, RecordDecl *RD,
Joel E. Denny7d5bc552019-08-22 03:34:30 +00002167 CapturedRegionKind K,
2168 unsigned OpenMPCaptureLevel) {
2169 auto *CSI = new CapturedRegionScopeInfo(
Alexey Bataev7ace49d2016-05-17 08:55:33 +00002170 getDiagnostics(), S, CD, RD, CD->getContextParam(), K,
Joel E. Denny7d5bc552019-08-22 03:34:30 +00002171 (getLangOpts().OpenMP && K == CR_OpenMP) ? getOpenMPNestingLevel() : 0,
2172 OpenMPCaptureLevel);
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002173 CSI->ReturnType = Context.VoidTy;
2174 FunctionScopes.push_back(CSI);
2175}
2176
2177CapturedRegionScopeInfo *Sema::getCurCapturedRegion() {
2178 if (FunctionScopes.empty())
Craig Topperc3ec1492014-05-26 06:22:03 +00002179 return nullptr;
Tareq A. Siraj6dfa25a2013-04-16 19:37:38 +00002180
2181 return dyn_cast<CapturedRegionScopeInfo>(FunctionScopes.back());
2182}
Ismail Pazarbasie5768d12015-05-18 19:59:11 +00002183
2184const llvm::MapVector<FieldDecl *, Sema::DeleteLocs> &
2185Sema::getMismatchingDeleteExpressions() const {
2186 return DeleteExprs;
2187}
Yaxun Liu5b746652016-12-18 05:18:55 +00002188
2189void Sema::setOpenCLExtensionForType(QualType T, llvm::StringRef ExtStr) {
2190 if (ExtStr.empty())
2191 return;
2192 llvm::SmallVector<StringRef, 1> Exts;
2193 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2194 auto CanT = T.getCanonicalType().getTypePtr();
2195 for (auto &I : Exts)
2196 OpenCLTypeExtMap[CanT].insert(I.str());
2197}
2198
2199void Sema::setOpenCLExtensionForDecl(Decl *FD, StringRef ExtStr) {
2200 llvm::SmallVector<StringRef, 1> Exts;
2201 ExtStr.split(Exts, " ", /* limit */ -1, /* keep empty */ false);
2202 if (Exts.empty())
2203 return;
2204 for (auto &I : Exts)
2205 OpenCLDeclExtMap[FD].insert(I.str());
2206}
2207
2208void Sema::setCurrentOpenCLExtensionForType(QualType T) {
2209 if (CurrOpenCLExtension.empty())
2210 return;
2211 setOpenCLExtensionForType(T, CurrOpenCLExtension);
2212}
2213
2214void Sema::setCurrentOpenCLExtensionForDecl(Decl *D) {
2215 if (CurrOpenCLExtension.empty())
2216 return;
2217 setOpenCLExtensionForDecl(D, CurrOpenCLExtension);
2218}
2219
Andrew Savonichev16f16992018-10-11 13:35:34 +00002220std::string Sema::getOpenCLExtensionsFromDeclExtMap(FunctionDecl *FD) {
2221 if (!OpenCLDeclExtMap.empty())
2222 return getOpenCLExtensionsFromExtMap(FD, OpenCLDeclExtMap);
2223
2224 return "";
2225}
2226
2227std::string Sema::getOpenCLExtensionsFromTypeExtMap(FunctionType *FT) {
2228 if (!OpenCLTypeExtMap.empty())
2229 return getOpenCLExtensionsFromExtMap(FT, OpenCLTypeExtMap);
2230
2231 return "";
2232}
2233
2234template <typename T, typename MapT>
2235std::string Sema::getOpenCLExtensionsFromExtMap(T *FDT, MapT &Map) {
2236 std::string ExtensionNames = "";
2237 auto Loc = Map.find(FDT);
2238
2239 for (auto const& I : Loc->second) {
2240 ExtensionNames += I;
2241 ExtensionNames += " ";
2242 }
2243 ExtensionNames.pop_back();
2244
2245 return ExtensionNames;
2246}
2247
Yaxun Liu5b746652016-12-18 05:18:55 +00002248bool Sema::isOpenCLDisabledDecl(Decl *FD) {
2249 auto Loc = OpenCLDeclExtMap.find(FD);
2250 if (Loc == OpenCLDeclExtMap.end())
2251 return false;
2252 for (auto &I : Loc->second) {
2253 if (!getOpenCLOptions().isEnabled(I))
2254 return true;
2255 }
2256 return false;
2257}
2258
2259template <typename T, typename DiagLocT, typename DiagInfoT, typename MapT>
2260bool Sema::checkOpenCLDisabledTypeOrDecl(T D, DiagLocT DiagLoc,
2261 DiagInfoT DiagInfo, MapT &Map,
2262 unsigned Selector,
2263 SourceRange SrcRange) {
2264 auto Loc = Map.find(D);
2265 if (Loc == Map.end())
2266 return false;
2267 bool Disabled = false;
2268 for (auto &I : Loc->second) {
2269 if (I != CurrOpenCLExtension && !getOpenCLOptions().isEnabled(I)) {
2270 Diag(DiagLoc, diag::err_opencl_requires_extension) << Selector << DiagInfo
2271 << I << SrcRange;
2272 Disabled = true;
2273 }
2274 }
2275 return Disabled;
2276}
2277
2278bool Sema::checkOpenCLDisabledTypeDeclSpec(const DeclSpec &DS, QualType QT) {
2279 // Check extensions for declared types.
2280 Decl *Decl = nullptr;
2281 if (auto TypedefT = dyn_cast<TypedefType>(QT.getTypePtr()))
2282 Decl = TypedefT->getDecl();
2283 if (auto TagT = dyn_cast<TagType>(QT.getCanonicalType().getTypePtr()))
2284 Decl = TagT->getDecl();
2285 auto Loc = DS.getTypeSpecTypeLoc();
Alexey Sotkin73ae7cb2018-09-03 11:43:22 +00002286
2287 // Check extensions for vector types.
2288 // e.g. double4 is not allowed when cl_khr_fp64 is absent.
2289 if (QT->isExtVectorType()) {
2290 auto TypePtr = QT->castAs<ExtVectorType>()->getElementType().getTypePtr();
2291 return checkOpenCLDisabledTypeOrDecl(TypePtr, Loc, QT, OpenCLTypeExtMap);
2292 }
2293
Yaxun Liu5b746652016-12-18 05:18:55 +00002294 if (checkOpenCLDisabledTypeOrDecl(Decl, Loc, QT, OpenCLDeclExtMap))
2295 return true;
2296
2297 // Check extensions for builtin types.
2298 return checkOpenCLDisabledTypeOrDecl(QT.getCanonicalType().getTypePtr(), Loc,
2299 QT, OpenCLTypeExtMap);
2300}
2301
Joey Gouly186791d2017-06-30 14:23:01 +00002302bool Sema::checkOpenCLDisabledDecl(const NamedDecl &D, const Expr &E) {
2303 IdentifierInfo *FnName = D.getIdentifier();
Stephen Kellyf2ceec42018-08-09 21:08:08 +00002304 return checkOpenCLDisabledTypeOrDecl(&D, E.getBeginLoc(), FnName,
Yaxun Liu5b746652016-12-18 05:18:55 +00002305 OpenCLDeclExtMap, 1, D.getSourceRange());
2306}