blob: a6a77661912542adc297c4cb85c801c9d9d95e14 [file] [log] [blame]
Ekaterina Romanovadac134e2016-01-10 16:18:09 +00001//===--- CompilerInvocation.cpp -------------------------------------------===//
Daniel Dunbar629f6bb2009-11-17 06:02:29 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
Mehdi Amini9670f842016-07-18 19:02:11 +000010#include "clang/Frontend/CompilerInvocation.h"
Douglas Gregor6623e1f2015-11-03 18:33:07 +000011#include "TestModuleFileExtension.h"
Chad Rosier7dbc9cf2016-01-06 14:35:46 +000012#include "clang/Basic/Builtins.h"
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +000013#include "clang/Basic/FileManager.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000014#include "clang/Basic/Version.h"
Chandler Carruthfd3cc702014-12-29 12:09:08 +000015#include "clang/Config/config.h"
Daniel Dunbarc70c3932009-12-01 03:16:53 +000016#include "clang/Driver/DriverDiagnostic.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000017#include "clang/Driver/Options.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000018#include "clang/Driver/Util.h"
Ben Langmuir8832c062014-04-15 18:16:25 +000019#include "clang/Frontend/FrontendDiagnostic.h"
Daniel Dunbarc70c3932009-12-01 03:16:53 +000020#include "clang/Frontend/LangStandard.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000021#include "clang/Frontend/Utils.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000022#include "clang/Lex/HeaderSearchOptions.h"
Mehdi Amini9670f842016-07-18 19:02:11 +000023#include "clang/Lex/PreprocessorOptions.h"
Sebastian Redlf5b13462010-08-18 23:57:17 +000024#include "clang/Serialization/ASTReader.h"
Douglas Gregor6623e1f2015-11-03 18:33:07 +000025#include "clang/Serialization/ModuleFileExtension.h"
Douglas Gregor7fd08492012-11-05 19:45:09 +000026#include "llvm/ADT/Hashing.h"
Saleem Abdulrasool9d45e772014-06-20 22:58:35 +000027#include "llvm/ADT/STLExtras.h"
Chandler Carruth0d9593d2015-01-14 11:29:14 +000028#include "llvm/ADT/SmallVector.h"
Daniel Dunbar629f6bb2009-11-17 06:02:29 +000029#include "llvm/ADT/StringExtras.h"
Daniel Dunbarc70c3932009-12-01 03:16:53 +000030#include "llvm/ADT/StringSwitch.h"
Duncan Sandsf610b5b2010-08-30 09:42:39 +000031#include "llvm/ADT/Triple.h"
Artem Belevich5d40ae32015-10-27 17:56:59 +000032#include "llvm/Linker/Linker.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000033#include "llvm/Option/Arg.h"
34#include "llvm/Option/ArgList.h"
35#include "llvm/Option/OptTable.h"
36#include "llvm/Option/Option.h"
Rong Xu9c6f1532016-03-02 20:59:36 +000037#include "llvm/ProfileData/InstrProfReader.h"
Saleem Abdulrasool62849c62014-05-08 02:28:32 +000038#include "llvm/Support/CodeGen.h"
Daniel Dunbar629f6bb2009-11-17 06:02:29 +000039#include "llvm/Support/ErrorHandling.h"
Rafael Espindola9678d272013-06-26 05:03:40 +000040#include "llvm/Support/FileSystem.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000041#include "llvm/Support/Host.h"
42#include "llvm/Support/Path.h"
Nico Rieck7857d462013-09-11 00:38:02 +000043#include "llvm/Support/Process.h"
Renato Golin4854d802015-11-09 12:40:41 +000044#include "llvm/Target/TargetOptions.h"
Yaxun Liub5f176e2016-06-29 19:39:32 +000045#include "llvm/Support/ScopedPrinter.h"
Benjamin Kramer4527fb22014-03-02 17:08:31 +000046#include <atomic>
Ahmed Charlesdfca6f92014-03-09 11:36:40 +000047#include <memory>
Douglas Gregord7193792013-05-10 21:54:08 +000048#include <sys/stat.h>
Rafael Espindola8a8e5542014-06-12 17:19:42 +000049#include <system_error>
Daniel Dunbar629f6bb2009-11-17 06:02:29 +000050using namespace clang;
51
Ted Kremenek8cf47df2011-11-17 23:01:24 +000052//===----------------------------------------------------------------------===//
53// Initialization.
54//===----------------------------------------------------------------------===//
55
Ted Kremenek2acedbd2011-11-18 04:32:13 +000056CompilerInvocationBase::CompilerInvocationBase()
Douglas Gregor811db4e2012-10-23 22:26:28 +000057 : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()),
Douglas Gregorb85b9cc2012-10-24 16:19:39 +000058 DiagnosticOpts(new DiagnosticOptions()),
Douglas Gregore81699d2012-10-24 17:01:35 +000059 HeaderSearchOpts(new HeaderSearchOptions()),
60 PreprocessorOpts(new PreprocessorOptions()) {}
Ted Kremenek8cf47df2011-11-17 23:01:24 +000061
Ted Kremenek2acedbd2011-11-18 04:32:13 +000062CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &X)
David Blaikieea4395e2017-01-06 19:49:01 +000063 : LangOpts(new LangOptions(*X.getLangOpts())),
64 TargetOpts(new TargetOptions(X.getTargetOpts())),
65 DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
66 HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
67 PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())) {}
Ted Kremenek8cf47df2011-11-17 23:01:24 +000068
Angel Garcia Gomez637d1e62015-10-20 13:23:58 +000069CompilerInvocationBase::~CompilerInvocationBase() {}
Alp Tokerc7dc0622014-05-11 22:10:52 +000070
Ted Kremenek8cf47df2011-11-17 23:01:24 +000071//===----------------------------------------------------------------------===//
Richard Smith33fd5512012-11-01 03:48:49 +000072// Deserialization (from args)
Daniel Dunbarc70c3932009-12-01 03:16:53 +000073//===----------------------------------------------------------------------===//
74
75using namespace clang::driver;
James Molloya3c85b82012-05-01 14:57:16 +000076using namespace clang::driver::options;
Reid Kleckner898229a2013-06-14 17:17:23 +000077using namespace llvm::opt;
Daniel Dunbarc70c3932009-12-01 03:16:53 +000078
Daniel Dunbarc70c3932009-12-01 03:16:53 +000079//
80
Peter Collingbourneb8e5dd42010-12-04 01:50:36 +000081static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
David Blaikie9c902b52011-09-25 23:23:43 +000082 DiagnosticsEngine &Diags) {
Peter Collingbourne31587c82010-12-04 01:50:45 +000083 unsigned DefaultOpt = 0;
84 if (IK == IK_OpenCL && !Args.hasArg(OPT_cl_opt_disable))
85 DefaultOpt = 2;
James Molloya3c85b82012-05-01 14:57:16 +000086
87 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
88 if (A->getOption().matches(options::OPT_O0))
89 return 0;
90
Chad Rosier153d7c62013-04-10 21:26:02 +000091 if (A->getOption().matches(options::OPT_Ofast))
92 return 3;
93
James Molloya3c85b82012-05-01 14:57:16 +000094 assert (A->getOption().matches(options::OPT_O));
95
Dmitri Gribenkof8579502013-01-12 19:30:44 +000096 StringRef S(A->getValue());
James Molloya3c85b82012-05-01 14:57:16 +000097 if (S == "s" || S == "z" || S.empty())
98 return 2;
99
Sylvestre Ledrud340ccc2016-11-11 17:29:56 +0000100 if (S == "g")
101 return 1;
102
Reid Kleckner898229a2013-06-14 17:17:23 +0000103 return getLastArgIntValue(Args, OPT_O, DefaultOpt, Diags);
James Molloya3c85b82012-05-01 14:57:16 +0000104 }
105
106 return DefaultOpt;
107}
108
Chad Rosierf2d39642013-04-10 21:30:03 +0000109static unsigned getOptimizationLevelSize(ArgList &Args) {
James Molloya3c85b82012-05-01 14:57:16 +0000110 if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
111 if (A->getOption().matches(options::OPT_O)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000112 switch (A->getValue()[0]) {
James Molloya3c85b82012-05-01 14:57:16 +0000113 default:
114 return 0;
115 case 's':
116 return 1;
117 case 'z':
118 return 2;
119 }
120 }
121 }
122 return 0;
123}
124
Richard Smith3be1cb22014-08-07 00:24:21 +0000125static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group,
126 OptSpecifier GroupWithValue,
127 std::vector<std::string> &Diagnostics) {
128 for (Arg *A : Args.filtered(Group)) {
James Molloya3c85b82012-05-01 14:57:16 +0000129 if (A->getOption().getKind() == Option::FlagClass) {
Richard Smith3be1cb22014-08-07 00:24:21 +0000130 // The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add
131 // its name (minus the "W" or "R" at the beginning) to the warning list.
132 Diagnostics.push_back(A->getOption().getName().drop_front(1));
133 } else if (A->getOption().matches(GroupWithValue)) {
134 // This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic group.
135 Diagnostics.push_back(A->getOption().getName().drop_front(1).rtrim("=-"));
James Molloya3c85b82012-05-01 14:57:16 +0000136 } else {
Richard Smith3be1cb22014-08-07 00:24:21 +0000137 // Otherwise, add its value (for OPT_W_Joined and similar).
138 for (const char *Arg : A->getValues())
Benjamin Kramer3204b152015-05-29 19:42:19 +0000139 Diagnostics.emplace_back(Arg);
James Molloya3c85b82012-05-01 14:57:16 +0000140 }
141 }
Peter Collingbourneb8e5dd42010-12-04 01:50:36 +0000142}
143
Chad Rosier7dbc9cf2016-01-06 14:35:46 +0000144static void getAllNoBuiltinFuncValues(ArgList &Args,
145 std::vector<std::string> &Funcs) {
146 SmallVector<const char *, 8> Values;
147 for (const auto &Arg : Args) {
148 const Option &O = Arg->getOption();
149 if (O.matches(options::OPT_fno_builtin_)) {
150 const char *FuncName = Arg->getValue();
151 if (Builtin::Context::isBuiltinFunc(FuncName))
152 Values.push_back(FuncName);
153 }
154 }
155 Funcs.insert(Funcs.end(), Values.begin(), Values.end());
156}
157
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000158static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
David Blaikie9c902b52011-09-25 23:23:43 +0000159 DiagnosticsEngine &Diags) {
James Molloya3c85b82012-05-01 14:57:16 +0000160 using namespace options;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000161 bool Success = true;
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000162 if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000163 StringRef Name = A->getValue();
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000164 AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
165#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
166 .Case(CMDFLAG, NAME##Model)
Ted Kremeneka5770cd2012-08-31 04:35:58 +0000167#include "clang/StaticAnalyzer/Core/Analyses.def"
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000168 .Default(NumStores);
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000169 if (Value == NumStores) {
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000170 Diags.Report(diag::err_drv_invalid_value)
Daniel Dunbar0bcb62d2010-06-09 22:30:54 +0000171 << A->getAsString(Args) << Name;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000172 Success = false;
173 } else {
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000174 Opts.AnalysisStoreOpt = Value;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000175 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000176 }
177
178 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000179 StringRef Name = A->getValue();
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000180 AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
181#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
182 .Case(CMDFLAG, NAME##Model)
Ted Kremeneka5770cd2012-08-31 04:35:58 +0000183#include "clang/StaticAnalyzer/Core/Analyses.def"
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000184 .Default(NumConstraints);
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000185 if (Value == NumConstraints) {
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000186 Diags.Report(diag::err_drv_invalid_value)
Daniel Dunbar0bcb62d2010-06-09 22:30:54 +0000187 << A->getAsString(Args) << Name;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000188 Success = false;
189 } else {
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000190 Opts.AnalysisConstraintsOpt = Value;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000191 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000192 }
193
194 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000195 StringRef Name = A->getValue();
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000196 AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
Jordan Rose367843a2013-08-16 01:06:30 +0000197#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000198 .Case(CMDFLAG, PD_##NAME)
Ted Kremeneka5770cd2012-08-31 04:35:58 +0000199#include "clang/StaticAnalyzer/Core/Analyses.def"
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000200 .Default(NUM_ANALYSIS_DIAG_CLIENTS);
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000201 if (Value == NUM_ANALYSIS_DIAG_CLIENTS) {
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000202 Diags.Report(diag::err_drv_invalid_value)
Daniel Dunbar0bcb62d2010-06-09 22:30:54 +0000203 << A->getAsString(Args) << Name;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000204 Success = false;
205 } else {
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000206 Opts.AnalysisDiagOpt = Value;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000207 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000208 }
209
Anna Zaks8d4c8e12011-09-30 02:03:00 +0000210 if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000211 StringRef Name = A->getValue();
Anna Zaks8d4c8e12011-09-30 02:03:00 +0000212 AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name)
213#define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
214 .Case(CMDFLAG, NAME)
Ted Kremeneka5770cd2012-08-31 04:35:58 +0000215#include "clang/StaticAnalyzer/Core/Analyses.def"
Anna Zaks8d4c8e12011-09-30 02:03:00 +0000216 .Default(NumPurgeModes);
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000217 if (Value == NumPurgeModes) {
Anna Zaks8d4c8e12011-09-30 02:03:00 +0000218 Diags.Report(diag::err_drv_invalid_value)
219 << A->getAsString(Args) << Name;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000220 Success = false;
221 } else {
Anna Zaks8d4c8e12011-09-30 02:03:00 +0000222 Opts.AnalysisPurgeOpt = Value;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000223 }
Anna Zaks8d4c8e12011-09-30 02:03:00 +0000224 }
225
Anna Zaks0af3e062012-03-08 23:16:35 +0000226 if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000227 StringRef Name = A->getValue();
Anna Zaks0af3e062012-03-08 23:16:35 +0000228 AnalysisInliningMode Value = llvm::StringSwitch<AnalysisInliningMode>(Name)
229#define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
230 .Case(CMDFLAG, NAME)
Ted Kremeneka5770cd2012-08-31 04:35:58 +0000231#include "clang/StaticAnalyzer/Core/Analyses.def"
Anna Zaks0af3e062012-03-08 23:16:35 +0000232 .Default(NumInliningModes);
233 if (Value == NumInliningModes) {
234 Diags.Report(diag::err_drv_invalid_value)
235 << A->getAsString(Args) << Name;
236 Success = false;
237 } else {
238 Opts.InliningMode = Value;
239 }
240 }
241
Argyrios Kyrtzidis17bee3e2011-02-25 00:09:51 +0000242 Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
Gabor Horvathc4309902016-08-08 13:41:04 +0000243 Opts.ShowEnabledCheckerList = Args.hasArg(OPT_analyzer_list_enabled_checkers);
Anna Zaksd5478fd2014-08-29 20:01:38 +0000244 Opts.DisableAllChecks = Args.hasArg(OPT_analyzer_disable_all_checks);
245
Ted Kremenekb8f8b352012-08-30 19:26:53 +0000246 Opts.visualizeExplodedGraphWithGraphViz =
247 Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
248 Opts.visualizeExplodedGraphWithUbiGraph =
249 Args.hasArg(OPT_analyzer_viz_egraph_ubigraph);
Anna Zaks72eee392012-03-28 19:59:16 +0000250 Opts.NoRetryExhausted = Args.hasArg(OPT_analyzer_disable_retry_exhausted);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000251 Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
252 Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
Ted Kremenek68189912009-12-07 22:06:12 +0000253 Opts.AnalyzeNestedBlocks =
254 Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
Ted Kremenek6f5131f2012-08-30 19:26:48 +0000255 Opts.eagerlyAssumeBinOpBifurcation = Args.hasArg(OPT_analyzer_eagerly_assume);
Daniel Dunbar37300482010-05-20 16:54:55 +0000256 Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
Ted Kremenek4a2b2372010-08-03 00:09:51 +0000257 Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000258 Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
Reid Kleckner898229a2013-06-14 17:17:23 +0000259 Opts.maxBlockVisitOnPath =
260 getLastArgIntValue(Args, OPT_analyzer_max_loop, 4, Diags);
Anna Zaksb0286542012-02-27 21:33:16 +0000261 Opts.PrintStats = Args.hasArg(OPT_analyzer_stats);
Anna Zaks26508772012-03-02 19:05:03 +0000262 Opts.InlineMaxStackDepth =
Reid Kleckner898229a2013-06-14 17:17:23 +0000263 getLastArgIntValue(Args, OPT_analyzer_inline_max_stack_depth,
264 Opts.InlineMaxStackDepth, Diags);
Argyrios Kyrtzidis556c45e2011-02-14 18:13:31 +0000265
266 Opts.CheckersControlList.clear();
Sean Silva14facf32015-06-09 01:57:17 +0000267 for (const Arg *A :
268 Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
Argyrios Kyrtzidis556c45e2011-02-14 18:13:31 +0000269 A->claim();
270 bool enable = (A->getOption().getID() == OPT_analyzer_checker);
Argyrios Kyrtzidisc08d89e2011-02-24 08:42:20 +0000271 // We can have a list of comma separated checker names, e.g:
272 // '-analyzer-checker=cocoa,unix'
Richard Smithbd55daf2012-11-01 04:30:05 +0000273 StringRef checkerList = A->getValue();
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000274 SmallVector<StringRef, 4> checkers;
Argyrios Kyrtzidisc08d89e2011-02-24 08:42:20 +0000275 checkerList.split(checkers, ",");
Benjamin Kramer3204b152015-05-29 19:42:19 +0000276 for (StringRef checker : checkers)
277 Opts.CheckersControlList.emplace_back(checker, enable);
Argyrios Kyrtzidis556c45e2011-02-14 18:13:31 +0000278 }
Jacques Pienaara50178c2015-02-24 21:45:33 +0000279
Ted Kremenekfb5351e2012-08-29 05:55:00 +0000280 // Go through the analyzer configuration options.
Sean Silva14facf32015-06-09 01:57:17 +0000281 for (const Arg *A : Args.filtered(OPT_analyzer_config)) {
Ted Kremenekfb5351e2012-08-29 05:55:00 +0000282 A->claim();
283 // We can have a list of comma separated config names, e.g:
Ted Kremenek53f3e7d2012-08-30 05:49:16 +0000284 // '-analyzer-config key1=val1,key2=val2'
Richard Smithbd55daf2012-11-01 04:30:05 +0000285 StringRef configList = A->getValue();
Ted Kremenekfb5351e2012-08-29 05:55:00 +0000286 SmallVector<StringRef, 4> configVals;
287 configList.split(configVals, ",");
288 for (unsigned i = 0, e = configVals.size(); i != e; ++i) {
289 StringRef key, val;
Benjamin Kramer867ea1d2014-03-02 13:01:17 +0000290 std::tie(key, val) = configVals[i].split("=");
Ted Kremenekfb5351e2012-08-29 05:55:00 +0000291 if (val.empty()) {
292 Diags.Report(SourceLocation(),
293 diag::err_analyzer_config_no_value) << configVals[i];
294 Success = false;
295 break;
296 }
Ted Kremenek53f3e7d2012-08-30 05:49:16 +0000297 if (val.find('=') != StringRef::npos) {
Ted Kremenekfb5351e2012-08-29 05:55:00 +0000298 Diags.Report(SourceLocation(),
299 diag::err_analyzer_config_multiple_values)
300 << configVals[i];
301 Success = false;
302 break;
303 }
304 Opts.Config[key] = val;
305 }
306 }
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000307
308 return Success;
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000309}
310
Fariborz Jahanianaa7b9aa2012-01-25 00:20:29 +0000311static bool ParseMigratorArgs(MigratorOptions &Opts, ArgList &Args) {
312 Opts.NoNSAllocReallocError = Args.hasArg(OPT_migrator_no_nsalloc_error);
Fariborz Jahanian48fd81b2012-01-26 20:57:58 +0000313 Opts.NoFinalizeRemoval = Args.hasArg(OPT_migrator_no_finalize_removal);
Fariborz Jahanianaa7b9aa2012-01-25 00:20:29 +0000314 return true;
315}
316
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +0000317static void ParseCommentArgs(CommentOptions &Opts, ArgList &Args) {
318 Opts.BlockCommandNames = Args.getAllArgValues(OPT_fcomment_block_commands);
Dmitri Gribenkoa7d16ce2013-04-10 15:35:17 +0000319 Opts.ParseAllComments = Args.hasArg(OPT_fparse_all_comments);
Dmitri Gribenkoacf2e782013-02-22 14:21:27 +0000320}
321
Saleem Abdulrasool62849c62014-05-08 02:28:32 +0000322static StringRef getCodeModel(ArgList &Args, DiagnosticsEngine &Diags) {
323 if (Arg *A = Args.getLastArg(OPT_mcode_model)) {
324 StringRef Value = A->getValue();
325 if (Value == "small" || Value == "kernel" || Value == "medium" ||
326 Value == "large")
327 return Value;
328 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Value;
329 }
330 return "default";
331}
332
Diego Novillod23ec942014-05-29 19:55:06 +0000333/// \brief Create a new Regex instance out of the string value in \p RpassArg.
334/// It returns a pointer to the newly generated Regex instance.
335static std::shared_ptr<llvm::Regex>
336GenerateOptimizationRemarkRegex(DiagnosticsEngine &Diags, ArgList &Args,
337 Arg *RpassArg) {
338 StringRef Val = RpassArg->getValue();
339 std::string RegexError;
340 std::shared_ptr<llvm::Regex> Pattern = std::make_shared<llvm::Regex>(Val);
341 if (!Pattern->isValid(RegexError)) {
342 Diags.Report(diag::err_drv_optimization_remark_pattern)
343 << RegexError << RpassArg->getAsString(Args);
344 Pattern.reset();
345 }
346 return Pattern;
347}
348
Eric Fiselier098e6de2015-06-13 07:11:40 +0000349static bool parseDiagnosticLevelMask(StringRef FlagName,
350 const std::vector<std::string> &Levels,
351 DiagnosticsEngine *Diags,
352 DiagnosticLevelMask &M) {
353 bool Success = true;
354 for (const auto &Level : Levels) {
355 DiagnosticLevelMask const PM =
356 llvm::StringSwitch<DiagnosticLevelMask>(Level)
357 .Case("note", DiagnosticLevelMask::Note)
358 .Case("remark", DiagnosticLevelMask::Remark)
359 .Case("warning", DiagnosticLevelMask::Warning)
360 .Case("error", DiagnosticLevelMask::Error)
361 .Default(DiagnosticLevelMask::None);
362 if (PM == DiagnosticLevelMask::None) {
363 Success = false;
364 if (Diags)
365 Diags->Report(diag::err_drv_invalid_value) << FlagName << Level;
366 }
367 M = M | PM;
368 }
369 return Success;
370}
371
Alexey Samsonov88459522015-01-12 22:39:12 +0000372static void parseSanitizerKinds(StringRef FlagName,
373 const std::vector<std::string> &Sanitizers,
374 DiagnosticsEngine &Diags, SanitizerSet &S) {
375 for (const auto &Sanitizer : Sanitizers) {
Peter Collingbournebf59c342015-05-11 21:39:20 +0000376 SanitizerMask K = parseSanitizerValue(Sanitizer, /*AllowGroups=*/false);
Peter Collingbourne3eea6772015-05-11 21:39:14 +0000377 if (K == 0)
Alexey Samsonov88459522015-01-12 22:39:12 +0000378 Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
379 else
380 S.set(K, true);
381 }
382}
383
Rong Xu9c6f1532016-03-02 20:59:36 +0000384// Set the profile kind for fprofile-instrument.
385static void setPGOInstrumentor(CodeGenOptions &Opts, ArgList &Args,
386 DiagnosticsEngine &Diags) {
387 Arg *A = Args.getLastArg(OPT_fprofile_instrument_EQ);
388 if (A == nullptr)
389 return;
390 StringRef S = A->getValue();
391 unsigned I = llvm::StringSwitch<unsigned>(S)
392 .Case("none", CodeGenOptions::ProfileNone)
393 .Case("clang", CodeGenOptions::ProfileClangInstr)
394 .Case("llvm", CodeGenOptions::ProfileIRInstr)
395 .Default(~0U);
396 if (I == ~0U) {
397 Diags.Report(diag::err_drv_invalid_pgo_instrumentor) << A->getAsString(Args)
398 << S;
399 return;
400 }
401 CodeGenOptions::ProfileInstrKind Instrumentor =
402 static_cast<CodeGenOptions::ProfileInstrKind>(I);
403 Opts.setProfileInstr(Instrumentor);
404}
405
406// Set the profile kind using fprofile-instrument-use-path.
407static void setPGOUseInstrumentor(CodeGenOptions &Opts,
Benjamin Kramer442b9a92016-05-29 11:04:56 +0000408 const Twine &ProfileName) {
Rong Xu9c6f1532016-03-02 20:59:36 +0000409 auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName);
410 // In error, return silently and let Clang PGOUse report the error message.
Vedant Kumarfa2d5952016-05-19 03:54:54 +0000411 if (auto E = ReaderOrErr.takeError()) {
412 llvm::consumeError(std::move(E));
Rong Xu9c6f1532016-03-02 20:59:36 +0000413 Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
414 return;
415 }
416 std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
417 std::move(ReaderOrErr.get());
418 if (PGOReader->isIRLevelProfile())
419 Opts.setProfileUse(CodeGenOptions::ProfileIRInstr);
420 else
421 Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
422}
423
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000424static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
Adrian Prantla7634472014-01-07 01:19:08 +0000425 DiagnosticsEngine &Diags,
426 const TargetOptions &TargetOpts) {
James Molloya3c85b82012-05-01 14:57:16 +0000427 using namespace options;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000428 bool Success = true;
Ekaterina Romanova9218a3b2015-12-10 18:52:50 +0000429 llvm::Triple Triple = llvm::Triple(TargetOpts.Triple);
Peter Collingbourneb8e5dd42010-12-04 01:50:36 +0000430
Rafael Espindolafd8de1c2014-12-16 21:57:03 +0000431 unsigned OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
Sylvestre Ledru5abf2ec2013-11-18 13:23:07 +0000432 // TODO: This could be done in Driver
433 unsigned MaxOptLevel = 3;
Rafael Espindolafd8de1c2014-12-16 21:57:03 +0000434 if (OptimizationLevel > MaxOptLevel) {
435 // If the optimization level is not supported, fall back on the default
436 // optimization
Sylvestre Ledru5abf2ec2013-11-18 13:23:07 +0000437 Diags.Report(diag::warn_drv_optimization_value)
438 << Args.getLastArg(OPT_O)->getAsString(Args) << "-O" << MaxOptLevel;
Rafael Espindolafd8de1c2014-12-16 21:57:03 +0000439 OptimizationLevel = MaxOptLevel;
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000440 }
Rafael Espindolafd8de1c2014-12-16 21:57:03 +0000441 Opts.OptimizationLevel = OptimizationLevel;
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000442
Chandler Carruthfcd33142016-12-23 01:24:49 +0000443 // At O0 we want to fully disable inlining outside of cases marked with
444 // 'alwaysinline' that are required for correctness.
445 Opts.setInlining((Opts.OptimizationLevel == 0)
446 ? CodeGenOptions::OnlyAlwaysInlining
447 : CodeGenOptions::NormalInlining);
448 // Explicit inlining flags can disable some or all inlining even at
449 // optimization levels above zero.
450 if (Arg *InlineArg = Args.getLastArg(
451 options::OPT_finline_functions, options::OPT_finline_hint_functions,
452 options::OPT_fno_inline_functions, options::OPT_fno_inline)) {
453 if (Opts.OptimizationLevel > 0) {
454 const Option &InlineOpt = InlineArg->getOption();
455 if (InlineOpt.matches(options::OPT_finline_functions))
456 Opts.setInlining(CodeGenOptions::NormalInlining);
457 else if (InlineOpt.matches(options::OPT_finline_hint_functions))
458 Opts.setInlining(CodeGenOptions::OnlyHintInlining);
459 else
460 Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining);
461 }
Hans Wennborg7a008882016-05-24 20:40:51 +0000462 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000463
Chandler Carruth50f9e892016-12-23 20:44:01 +0000464 Opts.ExperimentalNewPassManager = Args.hasFlag(
465 OPT_fexperimental_new_pass_manager, OPT_fno_experimental_new_pass_manager,
466 /* Default */ false);
467
Michael Zolotukhinc888dd02015-03-17 20:03:11 +0000468 if (Arg *A = Args.getLastArg(OPT_fveclib)) {
469 StringRef Name = A->getValue();
470 if (Name == "Accelerate")
471 Opts.setVecLib(CodeGenOptions::Accelerate);
Matt Masten6731dea2016-07-29 16:44:24 +0000472 else if (Name == "SVML")
473 Opts.setVecLib(CodeGenOptions::SVML);
Michael Zolotukhinc888dd02015-03-17 20:03:11 +0000474 else if (Name == "none")
475 Opts.setVecLib(CodeGenOptions::NoLibrary);
476 else
477 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
478 }
479
Douglas Katzman3459ce22015-10-08 04:24:12 +0000480 if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
Douglas Katzmana2ef81f2016-01-06 01:37:57 +0000481 unsigned Val =
482 llvm::StringSwitch<unsigned>(A->getValue())
Benjamin Kramer8c305922016-02-02 11:06:51 +0000483 .Case("line-tables-only", codegenoptions::DebugLineTablesOnly)
484 .Case("limited", codegenoptions::LimitedDebugInfo)
485 .Case("standalone", codegenoptions::FullDebugInfo)
Douglas Katzmana2ef81f2016-01-06 01:37:57 +0000486 .Default(~0U);
487 if (Val == ~0U)
488 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
489 << A->getValue();
490 else
Benjamin Kramer8c305922016-02-02 11:06:51 +0000491 Opts.setDebugInfo(static_cast<codegenoptions::DebugInfoKind>(Val));
Alexey Samsonov486e1fe2012-04-27 07:24:20 +0000492 }
Paul Robinson45784a72015-12-19 02:24:10 +0000493 if (Arg *A = Args.getLastArg(OPT_debugger_tuning_EQ)) {
Douglas Katzmana2ef81f2016-01-06 01:37:57 +0000494 unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
Paul Robinson9ef13db2016-02-05 23:23:25 +0000495 .Case("gdb", unsigned(llvm::DebuggerKind::GDB))
496 .Case("lldb", unsigned(llvm::DebuggerKind::LLDB))
497 .Case("sce", unsigned(llvm::DebuggerKind::SCE))
Douglas Katzmana2ef81f2016-01-06 01:37:57 +0000498 .Default(~0U);
499 if (Val == ~0U)
500 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
501 << A->getValue();
502 else
Paul Robinson9ef13db2016-02-05 23:23:25 +0000503 Opts.setDebuggerTuning(static_cast<llvm::DebuggerKind>(Val));
Paul Robinson45784a72015-12-19 02:24:10 +0000504 }
Douglas Katzman3459ce22015-10-08 04:24:12 +0000505 Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);
Eric Christophera2f7eb72012-10-18 21:52:18 +0000506 Opts.DebugColumnInfo = Args.hasArg(OPT_dwarf_column_info);
Douglas Katzman3459ce22015-10-08 04:24:12 +0000507 Opts.EmitCodeView = Args.hasArg(OPT_gcodeview);
Peter Collingbournefb532b92016-02-24 20:46:36 +0000508 Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables);
Peter Collingbourne3afb2662016-04-28 17:09:37 +0000509 Opts.LTOVisibilityPublicStd = Args.hasArg(OPT_flto_visibility_public_std);
Eric Christopherf1545832013-02-22 23:50:16 +0000510 Opts.SplitDwarfFile = Args.getLastArgValue(OPT_split_dwarf_file);
David Blaikiea45c31a2016-08-24 18:29:58 +0000511 Opts.SplitDwarfInlining = !Args.hasArg(OPT_fno_split_dwarf_inlining);
Adrian Prantl6b21ab22015-08-27 19:46:20 +0000512 Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);
Vitaly Buka9d4eb6f2016-06-02 00:24:20 +0000513 Opts.DebugExplicitImport = Triple.isPS4CPU();
Alexey Samsonov486e1fe2012-04-27 07:24:20 +0000514
Saleem Abdulrasool436256a2015-10-12 20:21:08 +0000515 for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ))
516 Opts.DebugPrefixMap.insert(StringRef(Arg).split('='));
517
Duncan P. N. Exon Smithbb618252015-04-15 01:16:18 +0000518 if (const Arg *A =
519 Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
520 Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;
521
Steven Wu546a1962015-07-17 20:09:56 +0000522 Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes);
Mehdi Amini7f873072017-01-06 23:18:09 +0000523 Opts.DisableLifetimeMarkers = Args.hasArg(OPT_disable_lifetimemarkers);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000524 Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
John McCall7ef5cb32011-03-18 02:56:14 +0000525 Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
Daniel Dunbard3f3d932011-06-21 18:54:46 +0000526 Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
527 OPT_fuse_register_sized_bitfield_access);
Chad Rosierb71f6aa2013-04-24 18:09:54 +0000528 Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
Manman Renf5d9d342013-10-11 20:48:38 +0000529 Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
Daniel Dunbar37300482010-05-20 16:54:55 +0000530 Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000531 Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
532 Opts.NoCommon = Args.hasArg(OPT_fno_common);
533 Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
Chad Rosierf2d39642013-04-10 21:30:03 +0000534 Opts.OptimizeSize = getOptimizationLevelSize(Args);
Daniel Dunbar6d5824f2010-06-07 23:19:17 +0000535 Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
536 Args.hasArg(OPT_ffreestanding));
Chad Rosier7dbc9cf2016-01-06 14:35:46 +0000537 if (Opts.SimplifyLibCalls)
538 getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
Chandler Carruth54c29102013-08-08 08:34:35 +0000539 Opts.UnrollLoops =
540 Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
Marianne Mailhot-Sarrasin21ac3bf2016-05-04 15:26:28 +0000541 (Opts.OptimizationLevel > 1));
Hal Finkelce0697f2013-11-17 16:03:29 +0000542 Opts.RerollLoops = Args.hasArg(OPT_freroll_loops);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000543
Saleem Abdulrasoolcfeb90d2014-02-23 00:40:30 +0000544 Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as);
Daniel Dunbare246fbe2013-04-16 18:21:19 +0000545 Opts.Autolink = !Args.hasArg(OPT_fno_autolink);
Diego Novillo5c297052013-11-13 12:22:39 +0000546 Opts.SampleProfileFile = Args.getLastArgValue(OPT_fprofile_sample_use_EQ);
Dehao Chenb3a70de2017-01-19 00:44:21 +0000547 Opts.DebugInfoForProfiling = Args.hasFlag(
548 OPT_fdebug_info_for_profiling, OPT_fno_debug_info_for_profiling, false);
Rong Xu9837ef52016-02-04 18:39:09 +0000549
Rong Xu9c6f1532016-03-02 20:59:36 +0000550 setPGOInstrumentor(Opts, Args, Diags);
551 Opts.InstrProfileOutput =
552 Args.getLastArgValue(OPT_fprofile_instrument_path_EQ);
553 Opts.ProfileInstrumentUsePath =
554 Args.getLastArgValue(OPT_fprofile_instrument_use_path_EQ);
555 if (!Opts.ProfileInstrumentUsePath.empty())
556 setPGOUseInstrumentor(Opts, Opts.ProfileInstrumentUsePath);
Rong Xu9837ef52016-02-04 18:39:09 +0000557
Diego Novilloc4b94da2015-08-05 23:27:40 +0000558 Opts.CoverageMapping =
559 Args.hasFlag(OPT_fcoverage_mapping, OPT_fno_coverage_mapping, false);
Alex Lorenzf2cf38e2014-08-08 23:41:24 +0000560 Opts.DumpCoverageMapping = Args.hasArg(OPT_dump_coverage_mapping);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000561 Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
Nirav Dave993a1392016-07-27 19:57:40 +0000562 Opts.PreserveAsmComments = !Args.hasArg(OPT_fno_preserve_as_comments);
Richard Smith351241c2016-04-07 21:46:12 +0000563 Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
John McCall31168b02011-06-15 23:02:42 +0000564 Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
Daniel Dunbarfe06df42010-03-20 04:15:41 +0000565 Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
566 Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
Saleem Abdulrasool62849c62014-05-08 02:28:32 +0000567 Opts.CodeModel = getCodeModel(Args, Diags);
Daniel Dunbar37300482010-05-20 16:54:55 +0000568 Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
Xinliang David Li4dff8752015-11-23 17:30:31 +0000569 Opts.DisableFPElim =
570 (Args.hasArg(OPT_mdisable_fp_elim) || Args.hasArg(OPT_pg));
Nick Lewycky92a6c742013-06-21 21:15:32 +0000571 Opts.DisableFree = Args.hasArg(OPT_disable_free);
Benjamin Kramer12f2de12016-03-14 13:23:58 +0000572 Opts.DiscardValueNames = Args.hasArg(OPT_discard_value_names);
Nick Lewycky1c8c4362012-01-23 08:29:12 +0000573 Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls);
Daniel Dunbar37300482010-05-20 16:54:55 +0000574 Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
Peter Collingbourne42254262010-12-04 01:51:33 +0000575 Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable);
Daniel Dunbar37300482010-05-20 16:54:55 +0000576 Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
Daniel Dunbar19939cc2011-12-09 23:41:18 +0000577 Opts.NoInfsFPMath = (Args.hasArg(OPT_menable_no_infinities) ||
Pekka Jaaskelainen37014502014-12-10 16:41:14 +0000578 Args.hasArg(OPT_cl_finite_math_only) ||
Daniel Dunbar19939cc2011-12-09 23:41:18 +0000579 Args.hasArg(OPT_cl_fast_relaxed_math));
580 Opts.NoNaNsFPMath = (Args.hasArg(OPT_menable_no_nans) ||
Pekka Jaaskelainen37014502014-12-10 16:41:14 +0000581 Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
582 Args.hasArg(OPT_cl_finite_math_only) ||
Daniel Dunbar19939cc2011-12-09 23:41:18 +0000583 Args.hasArg(OPT_cl_fast_relaxed_math));
Yaxun Liu79c99fb2016-07-08 20:28:29 +0000584 Opts.NoSignedZeros = (Args.hasArg(OPT_fno_signed_zeros) ||
585 Args.hasArg(OPT_cl_no_signed_zeros));
Yaxun Liu2c17e822016-08-09 19:43:38 +0000586 Opts.FlushDenorm = Args.hasArg(OPT_cl_denorms_are_zero);
Yaxun Liuffb60902016-08-09 20:10:18 +0000587 Opts.CorrectlyRoundedDivSqrt =
588 Args.hasArg(OPT_cl_fp32_correctly_rounded_divide_sqrt);
Sanjay Patel359b1052015-04-09 15:03:23 +0000589 Opts.ReciprocalMath = Args.hasArg(OPT_freciprocal_math);
Sjoerd Meijer0a8d4212016-08-30 08:09:45 +0000590 Opts.NoTrappingMath = Args.hasArg(OPT_fno_trapping_math);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000591 Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
Daniel Dunbar12100e22011-03-22 16:48:17 +0000592 Opts.BackendOptions = Args.getAllArgValues(OPT_backend_option);
Reid Kleckner898229a2013-06-14 17:17:23 +0000593 Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags);
Nick Lewyckyca6b90d2011-06-21 00:14:18 +0000594 Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
Joerg Sonnenbergera43604a2014-08-26 18:40:25 +0000595 Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
Eric Christopher006208c2013-04-04 06:29:47 +0000596 Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks);
Daniel Dunbarc43b6b22010-05-27 05:39:39 +0000597 Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
David Majnemer2b9349d2015-12-21 22:09:34 +0000598 Opts.IncrementalLinkerCompatible =
599 Args.hasArg(OPT_mincremental_linker_compatible);
Sriraman Tallam165a8842016-10-19 20:24:06 +0000600 Opts.PIECopyRelocations =
601 Args.hasArg(OPT_mpie_copy_relocations);
Daniel Dunbarbb7ac522010-07-01 01:31:45 +0000602 Opts.OmitLeafFramePointer = Args.hasArg(OPT_momit_leaf_frame_pointer);
Daniel Dunbar67919b22011-03-28 22:49:28 +0000603 Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
Nick Lewycky1d617ac2011-10-17 23:05:52 +0000604 Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000605 Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
Chandler Carruth8b4140d2012-03-27 23:58:37 +0000606 Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums);
Alex Lorenzc1608f72017-01-04 13:40:34 +0000607 Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return);
Piotr Padlewski338c9d02015-09-15 21:46:47 +0000608 Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers);
Chandler Carruth306bd2c2012-01-02 14:19:45 +0000609 Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
610 Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
Peter Collingbourne61d6a752010-12-04 01:51:23 +0000611 Args.hasArg(OPT_cl_fast_relaxed_math);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000612 Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
Daniel Dunbar37300482010-05-20 16:54:55 +0000613 Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
Jonathan Roelofsb140a102014-10-03 21:57:44 +0000614 Opts.ThreadModel = Args.getLastArgValue(OPT_mthread_model, "posix");
615 if (Opts.ThreadModel != "posix" && Opts.ThreadModel != "single")
616 Diags.Report(diag::err_drv_invalid_value)
617 << Args.getLastArg(OPT_mthread_model)->getAsString(Args)
618 << Opts.ThreadModel;
Bob Wilson14adb362012-02-03 06:27:22 +0000619 Opts.TrapFuncName = Args.getLastArgValue(OPT_ftrap_function_EQ);
Rafael Espindola66aa0452012-06-19 01:26:10 +0000620 Opts.UseInitArray = Args.hasArg(OPT_fuse_init_array);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000621
Nick Lewycky3a410fe2013-10-11 03:35:10 +0000622 Opts.FunctionSections = Args.hasFlag(OPT_ffunction_sections,
623 OPT_fno_function_sections, false);
624 Opts.DataSections = Args.hasFlag(OPT_fdata_sections,
625 OPT_fno_data_sections, false);
Rafael Espindola6b07a1c2015-02-20 18:08:57 +0000626 Opts.UniqueSectionNames = Args.hasFlag(OPT_funique_section_names,
627 OPT_fno_unique_section_names, true);
628
Nick Lewyckyf04f2372014-10-24 00:49:29 +0000629 Opts.MergeFunctions = Args.hasArg(OPT_fmerge_functions);
Chris Lattnerdc6040b2010-04-13 00:38:24 +0000630
Nirav Daved2f44d82016-04-05 17:50:43 +0000631 Opts.NoUseJumpTables = Args.hasArg(OPT_fno_jump_tables);
632
Teresa Johnson945bc502015-10-15 20:35:53 +0000633 Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ);
634 const Arg *A = Args.getLastArg(OPT_flto, OPT_flto_EQ);
Teresa Johnsona0d29402016-03-15 00:04:44 +0000635 Opts.EmitSummaryIndex = A && A->containsValue("thin");
Peter Collingbourne1e1475a2017-01-18 23:55:27 +0000636 Opts.LTOUnit = Args.hasFlag(OPT_flto_unit, OPT_fno_lto_unit, false);
Teresa Johnsonaff22322015-12-07 19:21:34 +0000637 if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
638 if (IK != IK_LLVM_IR)
639 Diags.Report(diag::err_drv_argument_only_allowed_with)
640 << A->getAsString(Args) << "-x ir";
641 Opts.ThinLTOIndexFile = Args.getLastArgValue(OPT_fthinlto_index_EQ);
642 }
Teresa Johnson8749d8042015-07-06 16:23:00 +0000643
David Majnemera5b195a2015-02-14 01:35:12 +0000644 Opts.MSVolatile = Args.hasArg(OPT_fms_volatile);
645
Nick Lewyckyd3f3e4f2013-06-25 01:49:44 +0000646 Opts.VectorizeBB = Args.hasArg(OPT_vectorize_slp_aggressive);
647 Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops);
648 Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp);
649
Daniel Dunbar37300482010-05-20 16:54:55 +0000650 Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
John McCallcfcb7752010-02-12 23:47:27 +0000651 Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
Daniel Dunbarfca18c1b42010-04-24 17:56:46 +0000652
Nick Lewyckyc02bbb62013-03-20 01:38:16 +0000653 Opts.DisableGCov = Args.hasArg(OPT_test_coverage);
Nick Lewycky207bce32011-04-21 23:44:07 +0000654 Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
655 Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
Nick Lewycky737a4522013-03-07 08:28:53 +0000656 if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
Nick Lewycky97e49ac2016-08-31 23:04:32 +0000657 Opts.CoverageDataFile = Args.getLastArgValue(OPT_coverage_data_file);
658 Opts.CoverageNotesFile = Args.getLastArgValue(OPT_coverage_notes_file);
Nick Lewycky737a4522013-03-07 08:28:53 +0000659 Opts.CoverageExtraChecksum = Args.hasArg(OPT_coverage_cfg_checksum);
Nick Lewycky6f15b2902013-03-20 02:14:38 +0000660 Opts.CoverageNoFunctionNamesInData =
661 Args.hasArg(OPT_coverage_no_function_names_in_data);
Justin Bogner4e462372015-03-16 23:52:21 +0000662 Opts.CoverageExitBlockBeforeBody =
663 Args.hasArg(OPT_coverage_exit_block_before_body);
Nick Lewycky737a4522013-03-07 08:28:53 +0000664 if (Args.hasArg(OPT_coverage_version_EQ)) {
665 StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
666 if (CoverageVersion.size() != 4) {
667 Diags.Report(diag::err_drv_invalid_value)
668 << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
669 << CoverageVersion;
670 } else {
Nick Lewyckyc8bf8242013-03-14 05:14:01 +0000671 memcpy(Opts.CoverageVersion, CoverageVersion.data(), 4);
Nick Lewycky737a4522013-03-07 08:28:53 +0000672 }
673 }
674 }
Steven Wu27fb5222016-05-11 16:26:03 +0000675 // Handle -fembed-bitcode option.
676 if (Arg *A = Args.getLastArg(OPT_fembed_bitcode_EQ)) {
677 StringRef Name = A->getValue();
678 unsigned Model = llvm::StringSwitch<unsigned>(Name)
679 .Case("off", CodeGenOptions::Embed_Off)
680 .Case("all", CodeGenOptions::Embed_All)
681 .Case("bitcode", CodeGenOptions::Embed_Bitcode)
682 .Case("marker", CodeGenOptions::Embed_Marker)
683 .Default(~0U);
684 if (Model == ~0U) {
685 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
686 Success = false;
687 } else
688 Opts.setEmbedBitcode(
689 static_cast<CodeGenOptions::EmbedBitcodeKind>(Model));
690 }
691 // FIXME: For backend options that are not yet recorded as function
692 // attributes in the IR, keep track of them so we can embed them in a
693 // separate data section and use them when building the bitcode.
694 if (Opts.getEmbedBitcode() == CodeGenOptions::Embed_All) {
695 for (const auto &A : Args) {
696 // Do not encode output and input.
697 if (A->getOption().getID() == options::OPT_o ||
698 A->getOption().getID() == options::OPT_INPUT ||
699 A->getOption().getID() == options::OPT_x ||
700 A->getOption().getID() == options::OPT_fembed_bitcode ||
701 (A->getOption().getGroup().isValid() &&
702 A->getOption().getGroup().getID() == options::OPT_W_Group))
703 continue;
704 ArgStringList ASL;
705 A->render(Args, ASL);
706 for (const auto &arg : ASL) {
707 StringRef ArgStr(arg);
708 Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end());
709 // using \00 to seperate each commandline options.
710 Opts.CmdArgs.push_back('\0');
711 }
712 }
713 }
Nick Lewycky737a4522013-03-07 08:28:53 +0000714
715 Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
Aaron Ballman7d2aecb2016-07-13 22:32:15 +0000716 Opts.XRayInstrumentFunctions = Args.hasArg(OPT_fxray_instrument);
717 Opts.XRayInstructionThreshold =
718 getLastArgIntValue(Args, OPT_fxray_instruction_threshold_, 200, Diags);
Nick Lewycky737a4522013-03-07 08:28:53 +0000719 Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
Nirav Dave0c86ccf2017-01-31 17:00:35 +0000720 Opts.CallFEntry = Args.hasArg(OPT_mfentry);
Nick Lewycky737a4522013-03-07 08:28:53 +0000721 Opts.EmitOpenCLArgMetadata = Args.hasArg(OPT_cl_kernel_arg_info);
David Blaikie7e2fd942014-03-27 20:47:30 +0000722 Opts.CompressDebugSections = Args.hasArg(OPT_compress_debug_sections);
Rafael Espindolaf8f01c32016-05-29 02:01:14 +0000723 Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
Nick Lewyckyba743b72011-10-21 02:32:14 +0000724 Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
Artem Belevich5d40ae32015-10-27 17:56:59 +0000725 for (auto A : Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_cuda_bitcode)) {
Justin Lebarb080b632017-01-25 21:29:48 +0000726 CodeGenOptions::BitcodeFileToLink F;
727 F.Filename = A->getValue();
728 if (A->getOption().matches(OPT_mlink_cuda_bitcode)) {
729 F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded |
730 llvm::Linker::Flags::InternalizeLinkedSymbols;
731 // When linking CUDA bitcode, propagate function attributes so that
732 // e.g. libdevice gets fast-math attrs if we're building with fast-math.
733 F.PropagateAttrs = true;
734 }
735 Opts.LinkBitcodeFiles.push_back(F);
Artem Belevich5d40ae32015-10-27 17:56:59 +0000736 }
Alexey Samsonov3f3b3ab2015-05-07 18:31:29 +0000737 Opts.SanitizeCoverageType =
738 getLastArgIntValue(Args, OPT_fsanitize_coverage_type, 0, Diags);
739 Opts.SanitizeCoverageIndirectCalls =
740 Args.hasArg(OPT_fsanitize_coverage_indirect_calls);
741 Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb);
742 Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp);
Kostya Serebryany3b419712016-08-30 01:27:03 +0000743 Opts.SanitizeCoverageTraceDiv = Args.hasArg(OPT_fsanitize_coverage_trace_div);
744 Opts.SanitizeCoverageTraceGep = Args.hasArg(OPT_fsanitize_coverage_trace_gep);
Alexey Samsonov3f3b3ab2015-05-07 18:31:29 +0000745 Opts.SanitizeCoverage8bitCounters =
746 Args.hasArg(OPT_fsanitize_coverage_8bit_counters);
Kostya Serebryanyd4590c72016-02-17 21:34:43 +0000747 Opts.SanitizeCoverageTracePC = Args.hasArg(OPT_fsanitize_coverage_trace_pc);
Kostya Serebryany60cdd612016-09-14 01:39:49 +0000748 Opts.SanitizeCoverageTracePCGuard =
749 Args.hasArg(OPT_fsanitize_coverage_trace_pc_guard);
Alexey Samsonov29524a92013-01-20 13:12:12 +0000750 Opts.SanitizeMemoryTrackOrigins =
Evgeniy Stepanov2bfcaab2014-03-20 14:58:36 +0000751 getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags);
Evgeniy Stepanov45be9e02015-07-10 20:07:16 +0000752 Opts.SanitizeMemoryUseAfterDtor =
753 Args.hasArg(OPT_fsanitize_memory_use_after_dtor);
Evgeniy Stepanovfd6f92d2015-12-15 23:00:20 +0000754 Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso);
Peter Collingbournedc134532016-01-16 00:31:22 +0000755 Opts.SanitizeStats = Args.hasArg(OPT_fsanitize_stats);
Vitaly Bukaa77ac1b2016-10-10 21:31:50 +0000756 if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_after_scope,
757 OPT_fno_sanitize_address_use_after_scope)) {
758 Opts.SanitizeAddressUseAfterScope =
759 A->getOption().getID() == OPT_fsanitize_address_use_after_scope;
760 }
Chad Rosierdb3da832012-08-21 16:16:06 +0000761 Opts.SSPBufferSize =
Reid Kleckner898229a2013-06-14 17:17:23 +0000762 getLastArgIntValue(Args, OPT_stack_protector_buffer_size, 8, Diags);
Nick Lewyckyf4d3f7a2011-12-06 03:33:03 +0000763 Opts.StackRealignment = Args.hasArg(OPT_mstackrealign);
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +0000764 if (Arg *A = Args.getLastArg(OPT_mstack_alignment)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000765 StringRef Val = A->getValue();
Douglas Gregorb0eea8b2012-10-23 20:05:01 +0000766 unsigned StackAlignment = Opts.StackAlignment;
767 Val.getAsInteger(10, StackAlignment);
768 Opts.StackAlignment = StackAlignment;
Joerg Sonnenbergerdb66ed02011-12-05 23:05:23 +0000769 }
Chris Lattner3c77a352010-06-22 00:03:40 +0000770
Hans Wennborg77dc2362015-01-20 19:45:50 +0000771 if (Arg *A = Args.getLastArg(OPT_mstack_probe_size)) {
772 StringRef Val = A->getValue();
773 unsigned StackProbeSize = Opts.StackProbeSize;
774 Val.getAsInteger(0, StackProbeSize);
775 Opts.StackProbeSize = StackProbeSize;
776 }
777
Daniel Dunbarfca18c1b42010-04-24 17:56:46 +0000778 if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000779 StringRef Name = A->getValue();
Daniel Dunbarfca18c1b42010-04-24 17:56:46 +0000780 unsigned Method = llvm::StringSwitch<unsigned>(Name)
781 .Case("legacy", CodeGenOptions::Legacy)
782 .Case("non-legacy", CodeGenOptions::NonLegacy)
783 .Case("mixed", CodeGenOptions::Mixed)
784 .Default(~0U);
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000785 if (Method == ~0U) {
Daniel Dunbarfca18c1b42010-04-24 17:56:46 +0000786 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000787 Success = false;
788 } else {
Douglas Gregorb0eea8b2012-10-23 20:05:01 +0000789 Opts.setObjCDispatchMethod(
790 static_cast<CodeGenOptions::ObjCDispatchMethodKind>(Method));
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000791 }
Daniel Dunbarfca18c1b42010-04-24 17:56:46 +0000792 }
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000793
Chih-Hung Hsieh2c656c92015-07-28 16:27:56 +0000794 Opts.EmulatedTLS =
795 Args.hasFlag(OPT_femulated_tls, OPT_fno_emulated_tls, false);
796
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000797 if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000798 StringRef Name = A->getValue();
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000799 unsigned Model = llvm::StringSwitch<unsigned>(Name)
800 .Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel)
801 .Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel)
802 .Case("initial-exec", CodeGenOptions::InitialExecTLSModel)
803 .Case("local-exec", CodeGenOptions::LocalExecTLSModel)
804 .Default(~0U);
805 if (Model == ~0U) {
806 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
807 Success = false;
808 } else {
Douglas Gregorb0eea8b2012-10-23 20:05:01 +0000809 Opts.setDefaultTLSModel(static_cast<CodeGenOptions::TLSModel>(Model));
Hans Wennborgf60f6af2012-06-28 08:01:44 +0000810 }
811 }
812
Lang Hames65992f42012-11-15 07:51:26 +0000813 if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
814 StringRef Val = A->getValue();
815 if (Val == "fast")
816 Opts.setFPContractMode(CodeGenOptions::FPC_Fast);
817 else if (Val == "on")
818 Opts.setFPContractMode(CodeGenOptions::FPC_On);
819 else if (Val == "off")
820 Opts.setFPContractMode(CodeGenOptions::FPC_Off);
821 else
822 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
823 }
824
Sjoerd Meijer0a8d4212016-08-30 08:09:45 +0000825 if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
826 StringRef Val = A->getValue();
827 if (Val == "ieee")
828 Opts.FPDenormalMode = "ieee";
829 else if (Val == "preserve-sign")
830 Opts.FPDenormalMode = "preserve-sign";
831 else if (Val == "positive-zero")
832 Opts.FPDenormalMode = "positive-zero";
833 else
834 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
835 }
836
John McCall1fe2a8c2013-06-18 02:46:29 +0000837 if (Arg *A = Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return)) {
838 if (A->getOption().matches(OPT_fpcc_struct_return)) {
839 Opts.setStructReturnConvention(CodeGenOptions::SRCK_OnStack);
840 } else {
841 assert(A->getOption().matches(OPT_freg_struct_return));
842 Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs);
843 }
844 }
845
Hans Wennborg75958c42013-08-08 00:17:41 +0000846 Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
Peter Collingbournedc134532016-01-16 00:31:22 +0000847 Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option);
Diego Novillo913690c2014-06-24 17:02:17 +0000848 bool NeedLocTracking = false;
Hans Wennborg75958c42013-08-08 00:17:41 +0000849
Hal Finkel8f96e822016-10-11 00:26:09 +0000850 Opts.OptRecordFile = Args.getLastArgValue(OPT_opt_record_file);
851 if (!Opts.OptRecordFile.empty())
852 NeedLocTracking = true;
853
Diego Novillo913690c2014-06-24 17:02:17 +0000854 if (Arg *A = Args.getLastArg(OPT_Rpass_EQ)) {
Diego Novillod23ec942014-05-29 19:55:06 +0000855 Opts.OptimizationRemarkPattern =
856 GenerateOptimizationRemarkRegex(Diags, Args, A);
Diego Novillo913690c2014-06-24 17:02:17 +0000857 NeedLocTracking = true;
858 }
Diego Novillod23ec942014-05-29 19:55:06 +0000859
Diego Novillo913690c2014-06-24 17:02:17 +0000860 if (Arg *A = Args.getLastArg(OPT_Rpass_missed_EQ)) {
Diego Novillod23ec942014-05-29 19:55:06 +0000861 Opts.OptimizationRemarkMissedPattern =
862 GenerateOptimizationRemarkRegex(Diags, Args, A);
Diego Novillo913690c2014-06-24 17:02:17 +0000863 NeedLocTracking = true;
864 }
Diego Novillod23ec942014-05-29 19:55:06 +0000865
Diego Novillo913690c2014-06-24 17:02:17 +0000866 if (Arg *A = Args.getLastArg(OPT_Rpass_analysis_EQ)) {
Diego Novillod23ec942014-05-29 19:55:06 +0000867 Opts.OptimizationRemarkAnalysisPattern =
868 GenerateOptimizationRemarkRegex(Diags, Args, A);
Diego Novillo913690c2014-06-24 17:02:17 +0000869 NeedLocTracking = true;
870 }
871
Adam Nemet1eea3e52016-09-13 04:32:40 +0000872 Opts.DiagnosticsWithHotness =
873 Args.hasArg(options::OPT_fdiagnostics_show_hotness);
874 if (Opts.DiagnosticsWithHotness &&
875 Opts.getProfileUse() == CodeGenOptions::ProfileNone)
876 Diags.Report(diag::warn_drv_fdiagnostics_show_hotness_requires_pgo);
877
Diego Novillo795f53b2014-10-22 13:00:05 +0000878 // If the user requested to use a sample profile for PGO, then the
879 // backend will need to track source location information so the profile
880 // can be incorporated into the IR.
881 if (!Opts.SampleProfileFile.empty())
882 NeedLocTracking = true;
883
884 // If the user requested a flag that requires source locations available in
885 // the backend, make sure that the backend tracks source location information.
Benjamin Kramer8c305922016-02-02 11:06:51 +0000886 if (NeedLocTracking && Opts.getDebugInfo() == codegenoptions::NoDebugInfo)
887 Opts.setDebugInfo(codegenoptions::LocTrackingOnly);
Diego Novillod23ec942014-05-29 19:55:06 +0000888
Saleem Abdulrasool76a4b952015-01-09 05:10:20 +0000889 Opts.RewriteMapFiles = Args.getAllArgValues(OPT_frewrite_map_file);
890
Alexey Samsonov88459522015-01-12 22:39:12 +0000891 // Parse -fsanitize-recover= arguments.
892 // FIXME: Report unrecoverable sanitizers incorrectly specified here.
893 parseSanitizerKinds("-fsanitize-recover=",
894 Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
895 Opts.SanitizeRecover);
Peter Collingbourne9881b782015-06-18 23:59:22 +0000896 parseSanitizerKinds("-fsanitize-trap=",
897 Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
898 Opts.SanitizeTrap);
Alexey Samsonov88459522015-01-12 22:39:12 +0000899
Artem Belevich52cc4872015-05-07 19:34:16 +0000900 Opts.CudaGpuBinaryFileNames =
901 Args.getAllArgValues(OPT_fcuda_include_gpubinary);
902
Marcin Koscielnickib31ee6d2016-05-04 23:37:40 +0000903 Opts.Backchain = Args.hasArg(OPT_mbackchain);
904
Filipe Cabecinhasab731f72016-05-12 16:51:36 +0000905 Opts.EmitCheckPathComponentsToStrip = getLastArgIntValue(
906 Args, OPT_fsanitize_undefined_strip_path_components_EQ, 0, Diags);
907
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000908 return Success;
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000909}
910
911static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
912 ArgList &Args) {
James Molloya3c85b82012-05-01 14:57:16 +0000913 using namespace options;
Daniel Dunbar37300482010-05-20 16:54:55 +0000914 Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
915 Opts.Targets = Args.getAllArgValues(OPT_MT);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000916 Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
Argyrios Kyrtzidis6d0753d2014-03-14 03:07:38 +0000917 Opts.IncludeModuleFiles = Args.hasArg(OPT_module_file_deps);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000918 Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
Daniel Dunbar27734fd2011-02-02 15:41:17 +0000919 Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
Daniel Dunbar1af1d27512011-02-02 21:11:31 +0000920 Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
Peter Collingbourne77b0e7f22011-07-12 19:35:15 +0000921 Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
Hans Wennborg0fd62072013-08-09 00:32:23 +0000922 Opts.PrintShowIncludes = Args.hasArg(OPT_show_includes);
Douglas Gregor2e129652012-02-02 23:45:13 +0000923 Opts.DOTOutputFile = Args.getLastArgValue(OPT_dependency_dot);
Justin Bogner86d12592014-06-19 19:36:03 +0000924 Opts.ModuleDependencyOutputDir =
925 Args.getLastArgValue(OPT_module_dependency_dir);
Paul Robinsond7214a72015-04-27 18:14:32 +0000926 if (Args.hasArg(OPT_MV))
927 Opts.OutputFormat = DependencyOutputFormat::NMake;
Ivan Krasin1193f2c2015-08-13 04:04:37 +0000928 // Add sanitizer blacklists as extra dependencies.
929 // They won't be discovered by the regular preprocessor, so
930 // we let make / ninja to know about this implicit dependency.
Ivan Krasin4c3f2372015-09-02 20:02:38 +0000931 Opts.ExtraDeps = Args.getAllArgValues(OPT_fdepfile_entry);
Richard Smithbe9b6c72015-08-13 18:30:25 +0000932 auto ModuleFiles = Args.getAllArgValues(OPT_fmodule_file);
933 Opts.ExtraDeps.insert(Opts.ExtraDeps.end(), ModuleFiles.begin(),
934 ModuleFiles.end());
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000935}
936
Bruno Cardoso Lopes681d7172016-05-27 20:43:00 +0000937static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
938 // Color diagnostics default to auto ("on" if terminal supports) in the driver
939 // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
940 // Support both clang's -f[no-]color-diagnostics and gcc's
941 // -f[no-]diagnostics-colors[=never|always|auto].
942 enum {
943 Colors_On,
944 Colors_Off,
945 Colors_Auto
946 } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
947 for (Arg *A : Args) {
948 const Option &O = A->getOption();
Bruno Cardoso Lopes681d7172016-05-27 20:43:00 +0000949 if (O.matches(options::OPT_fcolor_diagnostics) ||
950 O.matches(options::OPT_fdiagnostics_color)) {
951 ShowColors = Colors_On;
952 } else if (O.matches(options::OPT_fno_color_diagnostics) ||
953 O.matches(options::OPT_fno_diagnostics_color)) {
954 ShowColors = Colors_Off;
Yaron Keren9181e772016-12-10 14:55:14 +0000955 } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
Bruno Cardoso Lopes681d7172016-05-27 20:43:00 +0000956 StringRef Value(A->getValue());
957 if (Value == "always")
958 ShowColors = Colors_On;
959 else if (Value == "never")
960 ShowColors = Colors_Off;
961 else if (Value == "auto")
962 ShowColors = Colors_Auto;
963 }
964 }
Yaron Keren9181e772016-12-10 14:55:14 +0000965 return ShowColors == Colors_On ||
966 (ShowColors == Colors_Auto &&
967 llvm::sys::Process::StandardErrHasColors());
Bruno Cardoso Lopes681d7172016-05-27 20:43:00 +0000968}
969
Chad Rosierd6f716a2012-03-13 20:09:56 +0000970bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
Bruno Cardoso Lopes681d7172016-05-27 20:43:00 +0000971 DiagnosticsEngine *Diags,
Bruno Cardoso Lopes76952a72016-10-11 18:21:26 +0000972 bool DefaultDiagColor, bool DefaultShowOpt) {
James Molloya3c85b82012-05-01 14:57:16 +0000973 using namespace options;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +0000974 bool Success = true;
975
Daniel Dunbar6b584862011-04-07 18:11:14 +0000976 Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
Justin Bogner5a6a2fc2014-10-23 22:20:11 +0000977 if (Arg *A =
978 Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
979 Opts.DiagnosticSerializationFile = A->getValue();
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000980 Opts.IgnoreWarnings = Args.hasArg(OPT_w);
981 Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
982 Opts.Pedantic = Args.hasArg(OPT_pedantic);
983 Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
984 Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
Bruno Cardoso Lopes681d7172016-05-27 20:43:00 +0000985 Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
Douglas Gregor643c9222011-05-21 17:07:29 +0000986 Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
987 OPT_fno_show_column,
988 /*Default=*/true);
Daniel Dunbarc70c3932009-12-01 03:16:53 +0000989 Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
990 Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
Hans Wennborgb30f4372016-08-26 15:45:36 +0000991 Opts.AbsolutePath = Args.hasArg(OPT_fdiagnostics_absolute_paths);
Bruno Cardoso Lopes76952a72016-10-11 18:21:26 +0000992 Opts.ShowOptionNames =
993 Args.hasFlag(OPT_fdiagnostics_show_option,
994 OPT_fno_diagnostics_show_option, DefaultShowOpt);
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +0000995
Nico Rieck7857d462013-09-11 00:38:02 +0000996 llvm::sys::Process::UseANSIEscapeCodes(Args.hasArg(OPT_fansi_escape_codes));
997
Chandler Carruth24284af2011-03-27 20:00:08 +0000998 // Default behavior is to not to show note include stacks.
999 Opts.ShowNoteIncludeStack = false;
Chandler Carruthb6766f02011-03-27 01:50:55 +00001000 if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
1001 OPT_fno_diagnostics_show_note_include_stack))
Chandler Carruth24284af2011-03-27 20:00:08 +00001002 if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
1003 Opts.ShowNoteIncludeStack = true;
Chandler Carruthb6766f02011-03-27 01:50:55 +00001004
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001005 StringRef ShowOverloads =
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00001006 Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
1007 if (ShowOverloads == "best")
Douglas Gregor79591782012-10-23 23:11:23 +00001008 Opts.setShowOverloads(Ovl_Best);
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00001009 else if (ShowOverloads == "all")
Douglas Gregor79591782012-10-23 23:11:23 +00001010 Opts.setShowOverloads(Ovl_All);
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00001011 else {
Chad Rosierd6f716a2012-03-13 20:09:56 +00001012 Success = false;
1013 if (Diags)
1014 Diags->Report(diag::err_drv_invalid_value)
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00001015 << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
1016 << ShowOverloads;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00001017 }
Jeffrey Yasskin2b99c6f2010-06-11 05:57:47 +00001018
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001019 StringRef ShowCategory =
Daniel Dunbar37300482010-05-20 16:54:55 +00001020 Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
Chris Lattnerbf6fac82010-05-04 21:55:25 +00001021 if (ShowCategory == "none")
1022 Opts.ShowCategories = 0;
1023 else if (ShowCategory == "id")
1024 Opts.ShowCategories = 1;
1025 else if (ShowCategory == "name")
1026 Opts.ShowCategories = 2;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00001027 else {
Chad Rosierd6f716a2012-03-13 20:09:56 +00001028 Success = false;
1029 if (Diags)
1030 Diags->Report(diag::err_drv_invalid_value)
Chris Lattnerbf6fac82010-05-04 21:55:25 +00001031 << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
1032 << ShowCategory;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00001033 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001034
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001035 StringRef Format =
Douglas Gregor643c9222011-05-21 17:07:29 +00001036 Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
1037 if (Format == "clang")
Douglas Gregor79591782012-10-23 23:11:23 +00001038 Opts.setFormat(DiagnosticOptions::Clang);
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00001039 else if (Format == "msvc")
David Majnemer8ab003a2015-02-02 19:30:52 +00001040 Opts.setFormat(DiagnosticOptions::MSVC);
Hans Wennborgf4aee182013-09-24 00:08:55 +00001041 else if (Format == "msvc-fallback") {
David Majnemer8ab003a2015-02-02 19:30:52 +00001042 Opts.setFormat(DiagnosticOptions::MSVC);
Hans Wennborgf4aee182013-09-24 00:08:55 +00001043 Opts.CLFallbackMode = true;
1044 } else if (Format == "vi")
Douglas Gregor79591782012-10-23 23:11:23 +00001045 Opts.setFormat(DiagnosticOptions::Vi);
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00001046 else {
Chad Rosierd6f716a2012-03-13 20:09:56 +00001047 Success = false;
1048 if (Diags)
1049 Diags->Report(diag::err_drv_invalid_value)
Douglas Gregor643c9222011-05-21 17:07:29 +00001050 << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
1051 << Format;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00001052 }
Eric Fiselier098e6de2015-06-13 07:11:40 +00001053
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001054 Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
Douglas Gregoreec975c2010-08-19 20:24:43 +00001055 Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
Richard Smith0b50cb72012-11-14 23:55:25 +00001056 Opts.ShowPresumedLoc = !Args.hasArg(OPT_fno_diagnostics_use_presumed_location);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001057 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
Eric Fiselier098e6de2015-06-13 07:11:40 +00001058 DiagnosticLevelMask DiagMask = DiagnosticLevelMask::None;
1059 Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=",
1060 Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ),
1061 Diags, DiagMask);
1062 if (Args.hasArg(OPT_verify_ignore_unexpected))
1063 DiagMask = DiagnosticLevelMask::All;
1064 Opts.setVerifyIgnoreUnexpected(DiagMask);
Richard Trieu91844232012-06-26 18:18:47 +00001065 Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
1066 Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
Reid Kleckner898229a2013-06-14 17:17:23 +00001067 Opts.ErrorLimit = getLastArgIntValue(Args, OPT_ferror_limit, 0, Diags);
1068 Opts.MacroBacktraceLimit =
1069 getLastArgIntValue(Args, OPT_fmacro_backtrace_limit,
Douglas Gregorcd121fb2010-05-04 17:13:42 +00001070 DiagnosticOptions::DefaultMacroBacktraceLimit, Diags);
Reid Kleckner898229a2013-06-14 17:17:23 +00001071 Opts.TemplateBacktraceLimit = getLastArgIntValue(
1072 Args, OPT_ftemplate_backtrace_limit,
1073 DiagnosticOptions::DefaultTemplateBacktraceLimit, Diags);
1074 Opts.ConstexprBacktraceLimit = getLastArgIntValue(
1075 Args, OPT_fconstexpr_backtrace_limit,
1076 DiagnosticOptions::DefaultConstexprBacktraceLimit, Diags);
Nick Lewycky24653262014-12-16 21:39:02 +00001077 Opts.SpellCheckingLimit = getLastArgIntValue(
1078 Args, OPT_fspell_checking_limit,
1079 DiagnosticOptions::DefaultSpellCheckingLimit, Diags);
Reid Kleckner898229a2013-06-14 17:17:23 +00001080 Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop,
Chris Lattner3d756f12010-01-13 03:06:50 +00001081 DiagnosticOptions::DefaultTabStop, Diags);
1082 if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
Chris Lattner3d756f12010-01-13 03:06:50 +00001083 Opts.TabStop = DiagnosticOptions::DefaultTabStop;
Chad Rosierd6f716a2012-03-13 20:09:56 +00001084 if (Diags)
1085 Diags->Report(diag::warn_ignoring_ftabstop_value)
1086 << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
Chris Lattner3d756f12010-01-13 03:06:50 +00001087 }
Reid Kleckner898229a2013-06-14 17:17:23 +00001088 Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags);
Richard Smith3be1cb22014-08-07 00:24:21 +00001089 addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
1090 addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00001091
1092 return Success;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001093}
1094
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00001095static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
1096 Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
1097}
1098
Douglas Gregor6623e1f2015-11-03 18:33:07 +00001099/// Parse the argument to the -ftest-module-file-extension
1100/// command-line argument.
1101///
1102/// \returns true on error, false on success.
1103static bool parseTestModuleFileExtensionArg(StringRef Arg,
1104 std::string &BlockName,
1105 unsigned &MajorVersion,
1106 unsigned &MinorVersion,
1107 bool &Hashed,
1108 std::string &UserInfo) {
1109 SmallVector<StringRef, 5> Args;
1110 Arg.split(Args, ':', 5);
1111 if (Args.size() < 5)
1112 return true;
1113
1114 BlockName = Args[0];
1115 if (Args[1].getAsInteger(10, MajorVersion)) return true;
1116 if (Args[2].getAsInteger(10, MinorVersion)) return true;
1117 if (Args[3].getAsInteger(2, Hashed)) return true;
1118 if (Args.size() > 4)
1119 UserInfo = Args[4];
1120 return false;
1121}
1122
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001123static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
Erik Verbruggene0bde752016-10-27 14:17:10 +00001124 DiagnosticsEngine &Diags,
1125 bool &IsHeaderFile) {
James Molloya3c85b82012-05-01 14:57:16 +00001126 using namespace options;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001127 Opts.ProgramAction = frontend::ParseSyntaxOnly;
1128 if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
1129 switch (A->getOption().getID()) {
1130 default:
David Blaikie83d382b2011-09-23 05:06:16 +00001131 llvm_unreachable("Invalid option in group!");
Alexander Kornienko4de03592012-07-31 09:37:40 +00001132 case OPT_ast_list:
1133 Opts.ProgramAction = frontend::ASTDeclList; break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001134 case OPT_ast_dump:
Richard Smith35f986d2014-08-11 22:11:07 +00001135 case OPT_ast_dump_lookups:
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001136 Opts.ProgramAction = frontend::ASTDump; break;
1137 case OPT_ast_print:
1138 Opts.ProgramAction = frontend::ASTPrint; break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001139 case OPT_ast_view:
1140 Opts.ProgramAction = frontend::ASTView; break;
1141 case OPT_dump_raw_tokens:
1142 Opts.ProgramAction = frontend::DumpRawTokens; break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001143 case OPT_dump_tokens:
1144 Opts.ProgramAction = frontend::DumpTokens; break;
1145 case OPT_S:
1146 Opts.ProgramAction = frontend::EmitAssembly; break;
1147 case OPT_emit_llvm_bc:
1148 Opts.ProgramAction = frontend::EmitBC; break;
1149 case OPT_emit_html:
1150 Opts.ProgramAction = frontend::EmitHTML; break;
1151 case OPT_emit_llvm:
1152 Opts.ProgramAction = frontend::EmitLLVM; break;
1153 case OPT_emit_llvm_only:
1154 Opts.ProgramAction = frontend::EmitLLVMOnly; break;
Daniel Dunbar4c77a642010-05-25 18:41:01 +00001155 case OPT_emit_codegen_only:
1156 Opts.ProgramAction = frontend::EmitCodeGenOnly; break;
Daniel Dunbar92db0fb2010-02-03 01:18:43 +00001157 case OPT_emit_obj:
1158 Opts.ProgramAction = frontend::EmitObj; break;
Nick Lewycky784fad72010-04-24 01:30:46 +00001159 case OPT_fixit_EQ:
Richard Smithbd55daf2012-11-01 04:30:05 +00001160 Opts.FixItSuffix = A->getValue();
Nick Lewycky784fad72010-04-24 01:30:46 +00001161 // fall-through!
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001162 case OPT_fixit:
1163 Opts.ProgramAction = frontend::FixIt; break;
Douglas Gregor69f74f82011-08-25 22:30:56 +00001164 case OPT_emit_module:
1165 Opts.ProgramAction = frontend::GenerateModule; break;
Richard Smithbbcc9f02016-08-26 00:14:38 +00001166 case OPT_emit_module_interface:
1167 Opts.ProgramAction = frontend::GenerateModuleInterface; break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001168 case OPT_emit_pch:
1169 Opts.ProgramAction = frontend::GeneratePCH; break;
1170 case OPT_emit_pth:
1171 Opts.ProgramAction = frontend::GeneratePTH; break;
Daniel Dunbar1c201fb2010-03-19 19:44:04 +00001172 case OPT_init_only:
1173 Opts.ProgramAction = frontend::InitOnly; break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001174 case OPT_fsyntax_only:
1175 Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00001176 case OPT_module_file_info:
1177 Opts.ProgramAction = frontend::ModuleFileInfo; break;
Ben Langmuir2cb4a782014-02-05 22:21:15 +00001178 case OPT_verify_pch:
1179 Opts.ProgramAction = frontend::VerifyPCH; break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001180 case OPT_print_decl_contexts:
1181 Opts.ProgramAction = frontend::PrintDeclContext; break;
Douglas Gregoraf82e352010-07-20 20:18:03 +00001182 case OPT_print_preamble:
1183 Opts.ProgramAction = frontend::PrintPreamble; break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001184 case OPT_E:
1185 Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001186 case OPT_rewrite_macros:
1187 Opts.ProgramAction = frontend::RewriteMacros; break;
1188 case OPT_rewrite_objc:
1189 Opts.ProgramAction = frontend::RewriteObjC; break;
1190 case OPT_rewrite_test:
1191 Opts.ProgramAction = frontend::RewriteTest; break;
1192 case OPT_analyze:
1193 Opts.ProgramAction = frontend::RunAnalysis; break;
Ted Kremenekf7639e12012-03-06 20:06:33 +00001194 case OPT_migrate:
1195 Opts.ProgramAction = frontend::MigrateSource; break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001196 case OPT_Eonly:
1197 Opts.ProgramAction = frontend::RunPreprocessorOnly; break;
1198 }
1199 }
Daniel Dunbar7c995e82010-06-16 16:59:23 +00001200
1201 if (const Arg* A = Args.getLastArg(OPT_plugin)) {
Benjamin Kramer3204b152015-05-29 19:42:19 +00001202 Opts.Plugins.emplace_back(A->getValue(0));
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001203 Opts.ProgramAction = frontend::PluginAction;
Richard Smithbd55daf2012-11-01 04:30:05 +00001204 Opts.ActionName = A->getValue();
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001205 }
Nico Weber2992efa2011-01-25 20:34:14 +00001206 Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
John Brawn6c789742016-03-15 12:51:40 +00001207 for (const Arg *AA : Args.filtered(OPT_plugin_arg))
1208 Opts.PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
Nico Weber2992efa2011-01-25 20:34:14 +00001209
Douglas Gregor6623e1f2015-11-03 18:33:07 +00001210 for (const std::string &Arg :
1211 Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
1212 std::string BlockName;
1213 unsigned MajorVersion;
1214 unsigned MinorVersion;
1215 bool Hashed;
1216 std::string UserInfo;
1217 if (parseTestModuleFileExtensionArg(Arg, BlockName, MajorVersion,
1218 MinorVersion, Hashed, UserInfo)) {
1219 Diags.Report(diag::err_test_module_file_extension_format) << Arg;
1220
1221 continue;
1222 }
1223
1224 // Add the testing module file extension.
1225 Opts.ModuleFileExtensions.push_back(
David Blaikie61137e12017-01-05 18:23:18 +00001226 std::make_shared<TestModuleFileExtension>(
1227 BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
Douglas Gregor6623e1f2015-11-03 18:33:07 +00001228 }
1229
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001230 if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
1231 Opts.CodeCompletionAt =
Richard Smithbd55daf2012-11-01 04:30:05 +00001232 ParsedSourceLocation::FromString(A->getValue());
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001233 if (Opts.CodeCompletionAt.FileName.empty())
1234 Diags.Report(diag::err_drv_invalid_value)
Richard Smithbd55daf2012-11-01 04:30:05 +00001235 << A->getAsString(Args) << A->getValue();
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001236 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001237 Opts.DisableFree = Args.hasArg(OPT_disable_free);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001238
Daniel Dunbar37300482010-05-20 16:54:55 +00001239 Opts.OutputFile = Args.getLastArgValue(OPT_o);
1240 Opts.Plugins = Args.getAllArgValues(OPT_load);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001241 Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
Daniel Dunbar215ca5f2009-12-03 07:01:58 +00001242 Opts.ShowHelp = Args.hasArg(OPT_help);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001243 Opts.ShowStats = Args.hasArg(OPT_print_stats);
1244 Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
Daniel Dunbar215ca5f2009-12-03 07:01:58 +00001245 Opts.ShowVersion = Args.hasArg(OPT_version);
Daniel Dunbar37300482010-05-20 16:54:55 +00001246 Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
1247 Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
Nick Lewycky078a5e22010-08-13 17:31:00 +00001248 Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
Argyrios Kyrtzidis24e9aff2012-01-26 02:40:48 +00001249 Opts.FixOnlyWarnings = Args.hasArg(OPT_fix_only_warnings);
1250 Opts.FixAndRecompile = Args.hasArg(OPT_fixit_recompile);
1251 Opts.FixToTemporaries = Args.hasArg(OPT_fixit_to_temp);
Richard Smith35f986d2014-08-11 22:11:07 +00001252 Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump);
Alexander Kornienko3db68ee2012-07-26 16:01:23 +00001253 Opts.ASTDumpFilter = Args.getLastArgValue(OPT_ast_dump_filter);
Richard Smith6ea05822013-06-24 01:45:33 +00001254 Opts.ASTDumpLookups = Args.hasArg(OPT_ast_dump_lookups);
Douglas Gregor137f1b92013-01-28 18:38:02 +00001255 Opts.UseGlobalModuleIndex = !Args.hasArg(OPT_fno_modules_global_index);
Douglas Gregorc1bbec82013-01-25 00:45:27 +00001256 Opts.GenerateGlobalModuleIndex = Opts.UseGlobalModuleIndex;
Richard Smith4a89a062014-12-06 01:13:41 +00001257 Opts.ModuleMapFiles = Args.getAllArgValues(OPT_fmodule_map_file);
Richard Smithe842a472014-10-22 02:05:46 +00001258 Opts.ModuleFiles = Args.getAllArgValues(OPT_fmodule_file);
Richard Smithfb1e7f72015-08-14 05:02:58 +00001259 Opts.ModulesEmbedFiles = Args.getAllArgValues(OPT_fmodules_embed_file_EQ);
Richard Smith919ce232015-11-24 04:22:21 +00001260 Opts.ModulesEmbedAllFiles = Args.hasArg(OPT_fmodules_embed_all_files);
Pierre Gousseau533a8932016-07-13 14:21:11 +00001261 Opts.IncludeTimestamps = !Args.hasArg(OPT_fno_pch_timestamp);
Richard Smithe842a472014-10-22 02:05:46 +00001262
Dmitri Gribenko3292d062012-07-02 17:35:10 +00001263 Opts.CodeCompleteOpts.IncludeMacros
1264 = Args.hasArg(OPT_code_completion_macros);
1265 Opts.CodeCompleteOpts.IncludeCodePatterns
1266 = Args.hasArg(OPT_code_completion_patterns);
1267 Opts.CodeCompleteOpts.IncludeGlobals
1268 = !Args.hasArg(OPT_no_code_completion_globals);
1269 Opts.CodeCompleteOpts.IncludeBriefComments
1270 = Args.hasArg(OPT_code_completion_brief_comments);
1271
Douglas Gregore9fc3772012-01-26 07:55:45 +00001272 Opts.OverrideRecordLayoutsFile
1273 = Args.getLastArgValue(OPT_foverride_record_layout_EQ);
Artem Belevichb5bc9232015-09-22 17:23:22 +00001274 Opts.AuxTriple =
1275 llvm::Triple::normalize(Args.getLastArgValue(OPT_aux_triple));
Nico Weber2ca4be92016-03-01 23:16:44 +00001276 Opts.FindPchSource = Args.getLastArgValue(OPT_find_pch_source_EQ);
Matthias Braunabb6eea2016-09-26 18:53:34 +00001277 Opts.StatsFile = Args.getLastArgValue(OPT_stats_file);
Artem Belevichb5bc9232015-09-22 17:23:22 +00001278
John McCalld70fb982011-06-15 23:25:17 +00001279 if (const Arg *A = Args.getLastArg(OPT_arcmt_check,
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00001280 OPT_arcmt_modify,
1281 OPT_arcmt_migrate)) {
John McCalld70fb982011-06-15 23:25:17 +00001282 switch (A->getOption().getID()) {
1283 default:
1284 llvm_unreachable("missed a case");
1285 case OPT_arcmt_check:
1286 Opts.ARCMTAction = FrontendOptions::ARCMT_Check;
1287 break;
1288 case OPT_arcmt_modify:
1289 Opts.ARCMTAction = FrontendOptions::ARCMT_Modify;
1290 break;
Argyrios Kyrtzidis7fbd97f2011-07-09 20:00:58 +00001291 case OPT_arcmt_migrate:
1292 Opts.ARCMTAction = FrontendOptions::ARCMT_Migrate;
1293 break;
John McCalld70fb982011-06-15 23:25:17 +00001294 }
1295 }
Ted Kremenekf7639e12012-03-06 20:06:33 +00001296 Opts.MTMigrateDir = Args.getLastArgValue(OPT_mt_migrate_directory);
Argyrios Kyrtzidisd5713632011-07-19 17:20:03 +00001297 Opts.ARCMTMigrateReportOut
1298 = Args.getLastArgValue(OPT_arcmt_migrate_report_output);
1299 Opts.ARCMTMigrateEmitARCErrors
1300 = Args.hasArg(OPT_arcmt_migrate_emit_arc_errors);
John McCalld70fb982011-06-15 23:25:17 +00001301
Ted Kremenekf7639e12012-03-06 20:06:33 +00001302 if (Args.hasArg(OPT_objcmt_migrate_literals))
1303 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Literals;
1304 if (Args.hasArg(OPT_objcmt_migrate_subscripting))
1305 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Subscripting;
Fariborz Jahaniana6556f72014-10-31 21:19:45 +00001306 if (Args.hasArg(OPT_objcmt_migrate_property_dot_syntax))
1307 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_PropertyDotSyntax;
Fariborz Jahaniand83ef842013-07-09 16:59:14 +00001308 if (Args.hasArg(OPT_objcmt_migrate_property))
1309 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Property;
Fariborz Jahanian55d6e6c2013-08-28 23:22:46 +00001310 if (Args.hasArg(OPT_objcmt_migrate_readonly_property))
1311 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ReadonlyProperty;
Fariborz Jahanianc1213862013-10-02 21:32:39 +00001312 if (Args.hasArg(OPT_objcmt_migrate_readwrite_property))
1313 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ReadwriteProperty;
Fariborz Jahanian2bfa2b92013-10-02 21:58:13 +00001314 if (Args.hasArg(OPT_objcmt_migrate_annotation))
1315 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Annotation;
Fariborz Jahanian23417072013-11-05 22:28:30 +00001316 if (Args.hasArg(OPT_objcmt_returns_innerpointer_property))
1317 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ReturnsInnerPointerProperty;
Fariborz Jahanian2bfa2b92013-10-02 21:58:13 +00001318 if (Args.hasArg(OPT_objcmt_migrate_instancetype))
1319 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Instancetype;
1320 if (Args.hasArg(OPT_objcmt_migrate_nsmacros))
1321 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_NsMacros;
1322 if (Args.hasArg(OPT_objcmt_migrate_protocol_conformance))
1323 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ProtocolConformance;
Fariborz Jahanian20a11242013-10-09 19:06:08 +00001324 if (Args.hasArg(OPT_objcmt_atomic_property))
1325 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_AtomicProperty;
Fariborz Jahanian2e793d62013-11-13 00:08:36 +00001326 if (Args.hasArg(OPT_objcmt_ns_nonatomic_iosonly))
1327 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty;
Argyrios Kyrtzidis4f2ecc62013-12-10 18:36:49 +00001328 if (Args.hasArg(OPT_objcmt_migrate_designated_init))
1329 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_DesignatedInitializer;
Fariborz Jahanianc1213862013-10-02 21:32:39 +00001330 if (Args.hasArg(OPT_objcmt_migrate_all))
1331 Opts.ObjCMTAction |= FrontendOptions::ObjCMT_MigrateDecls;
Ted Kremenekf7639e12012-03-06 20:06:33 +00001332
Argyrios Kyrtzidisd5ba86b2013-12-10 18:36:53 +00001333 Opts.ObjCMTWhiteListPath = Args.getLastArgValue(OPT_objcmt_whitelist_dir_path);
Argyrios Kyrtzidis61f20322013-11-14 16:33:29 +00001334
Ted Kremenekf7639e12012-03-06 20:06:33 +00001335 if (Opts.ARCMTAction != FrontendOptions::ARCMT_None &&
1336 Opts.ObjCMTAction != FrontendOptions::ObjCMT_None) {
1337 Diags.Report(diag::err_drv_argument_not_allowed_with)
1338 << "ARC migration" << "ObjC migration";
1339 }
1340
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001341 InputKind DashX = IK_None;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001342 if (const Arg *A = Args.getLastArg(OPT_x)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001343 DashX = llvm::StringSwitch<InputKind>(A->getValue())
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001344 .Case("c", IK_C)
1345 .Case("cl", IK_OpenCL)
Peter Collingbourne62089b82010-12-01 03:15:20 +00001346 .Case("cuda", IK_CUDA)
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001347 .Case("c++", IK_CXX)
Richard Smithdd4ad3d2016-08-30 19:06:26 +00001348 .Case("c++-module", IK_CXX)
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001349 .Case("objective-c", IK_ObjC)
1350 .Case("objective-c++", IK_ObjCXX)
1351 .Case("cpp-output", IK_PreprocessedC)
1352 .Case("assembler-with-cpp", IK_Asm)
1353 .Case("c++-cpp-output", IK_PreprocessedCXX)
Richard Smithdd4ad3d2016-08-30 19:06:26 +00001354 .Case("c++-module-cpp-output", IK_PreprocessedCXX)
Artem Belevich83a6dcc2015-03-19 17:32:06 +00001355 .Case("cuda-cpp-output", IK_PreprocessedCuda)
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001356 .Case("objective-c-cpp-output", IK_PreprocessedObjC)
Chris Lattner5045cf12011-04-09 07:09:31 +00001357 .Case("objc-cpp-output", IK_PreprocessedObjC)
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001358 .Case("objective-c++-cpp-output", IK_PreprocessedObjCXX)
Nico Weberc687cae2011-08-13 19:03:50 +00001359 .Case("objc++-cpp-output", IK_PreprocessedObjCXX)
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001360 .Case("c-header", IK_C)
Peter Collingbourne1deb5b62011-10-09 22:03:19 +00001361 .Case("cl-header", IK_OpenCL)
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001362 .Case("objective-c-header", IK_ObjC)
1363 .Case("c++-header", IK_CXX)
1364 .Case("objective-c++-header", IK_ObjCXX)
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00001365 .Cases("ast", "pcm", IK_AST)
Daniel Dunbar9507f9c2010-06-07 23:26:47 +00001366 .Case("ir", IK_LLVM_IR)
Pirama Arumuga Nainar8b788d02016-06-09 23:34:20 +00001367 .Case("renderscript", IK_RenderScript)
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001368 .Default(IK_None);
1369 if (DashX == IK_None)
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001370 Diags.Report(diag::err_drv_invalid_value)
Richard Smithbd55daf2012-11-01 04:30:05 +00001371 << A->getAsString(Args) << A->getValue();
Erik Verbruggene0bde752016-10-27 14:17:10 +00001372 IsHeaderFile = llvm::StringSwitch<bool>(A->getValue())
1373 .Case("c-header", true)
1374 .Case("cl-header", true)
1375 .Case("objective-c-header", true)
1376 .Case("c++-header", true)
1377 .Case("objective-c++-header", true)
1378 .Default(false);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001379 }
1380
1381 // '-' is the default input if none is given.
Daniel Dunbar37300482010-05-20 16:54:55 +00001382 std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001383 Opts.Inputs.clear();
1384 if (Inputs.empty())
1385 Inputs.push_back("-");
1386 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001387 InputKind IK = DashX;
1388 if (IK == IK_None) {
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001389 IK = FrontendOptions::getInputKindForExtension(
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001390 StringRef(Inputs[i]).rsplit('.').second);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001391 // FIXME: Remove this hack.
1392 if (i == 0)
1393 DashX = IK;
1394 }
Benjamin Kramer3204b152015-05-29 19:42:19 +00001395 Opts.Inputs.emplace_back(std::move(Inputs[i]), IK);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001396 }
1397
1398 return DashX;
1399}
1400
Daniel Dunbara5a166d2009-12-15 00:06:45 +00001401std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
1402 void *MainAddr) {
Alexey Samsonov6465d4f2014-12-29 21:28:15 +00001403 std::string ClangExecutable =
1404 llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
Chandler Carruthfd3cc702014-12-29 12:09:08 +00001405 StringRef Dir = llvm::sys::path::parent_path(ClangExecutable);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001406
Chandler Carruthfd3cc702014-12-29 12:09:08 +00001407 // Compute the path to the resource directory.
1408 StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
1409 SmallString<128> P(Dir);
Yaron Kerena9107412015-08-05 20:06:56 +00001410 if (ClangResourceDir != "")
Chandler Carruthfd3cc702014-12-29 12:09:08 +00001411 llvm::sys::path::append(P, ClangResourceDir);
Yaron Kerena9107412015-08-05 20:06:56 +00001412 else
1413 llvm::sys::path::append(P, "..", Twine("lib") + CLANG_LIBDIR_SUFFIX,
1414 "clang", CLANG_VERSION_STRING);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001415
1416 return P.str();
1417}
1418
Daniel Dunbard6136772009-12-13 03:45:58 +00001419static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) {
James Molloya3c85b82012-05-01 14:57:16 +00001420 using namespace options;
Daniel Dunbar37300482010-05-20 16:54:55 +00001421 Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001422 Opts.Verbose = Args.hasArg(OPT_v);
Francois Pichet698f0192011-10-10 20:34:10 +00001423 Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
Daniel Dunbarb25bfde2011-10-11 18:20:10 +00001424 Opts.UseStandardSystemIncludes = !Args.hasArg(OPT_nostdsysteminc);
Douglas Gregor64b046f2010-03-24 20:13:48 +00001425 Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
Bob Wilsonb02ea3d2011-06-21 21:12:29 +00001426 if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +00001427 Opts.UseLibcxx = (strcmp(A->getValue(), "libc++") == 0);
Daniel Dunbar37300482010-05-20 16:54:55 +00001428 Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
Douglas Gregor35b04d62013-02-07 19:01:24 +00001429 Opts.ModuleCachePath = Args.getLastArgValue(OPT_fmodules_cache_path);
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00001430 Opts.ModuleUserBuildPath = Args.getLastArgValue(OPT_fmodules_user_build_path);
Manman Ren11f2a472016-08-18 17:42:15 +00001431 for (const Arg *A : Args.filtered(OPT_fprebuilt_module_path))
1432 Opts.AddPrebuiltModulePath(A->getValue());
Douglas Gregor1735f4e2011-09-13 23:15:45 +00001433 Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
Manman Ren47a44452016-07-26 17:12:17 +00001434 Opts.ModulesValidateDiagnosticOptions =
1435 !Args.hasArg(OPT_fmodules_disable_diagnostic_validation);
Richard Smith47972af2015-06-16 00:08:24 +00001436 Opts.ImplicitModuleMaps = Args.hasArg(OPT_fimplicit_module_maps);
Richard Smith9acb99e32014-12-10 03:09:48 +00001437 Opts.ModuleMapFileHomeIsCwd = Args.hasArg(OPT_fmodule_map_file_home_is_cwd);
Reid Kleckner898229a2013-06-14 17:17:23 +00001438 Opts.ModuleCachePruneInterval =
1439 getLastArgIntValue(Args, OPT_fmodules_prune_interval, 7 * 24 * 60 * 60);
1440 Opts.ModuleCachePruneAfter =
1441 getLastArgIntValue(Args, OPT_fmodules_prune_after, 31 * 24 * 60 * 60);
Dmitri Gribenkof430da42014-02-12 10:33:14 +00001442 Opts.ModulesValidateOncePerBuildSession =
1443 Args.hasArg(OPT_fmodules_validate_once_per_build_session);
1444 Opts.BuildSessionTimestamp =
1445 getLastArgUInt64Value(Args, OPT_fbuild_session_timestamp, 0);
Ben Langmuirdcf73862014-03-12 00:06:17 +00001446 Opts.ModulesValidateSystemHeaders =
1447 Args.hasArg(OPT_fmodules_validate_system_headers);
Adrian Prantlfb2398d2015-07-17 01:19:54 +00001448 if (const Arg *A = Args.getLastArg(OPT_fmodule_format_EQ))
1449 Opts.ModuleFormat = A->getValue();
Ben Langmuirdcf73862014-03-12 00:06:17 +00001450
Sean Silva14facf32015-06-09 01:57:17 +00001451 for (const Arg *A : Args.filtered(OPT_fmodules_ignore_macro)) {
1452 StringRef MacroDef = A->getValue();
Justin Lebar5e83dfe2016-10-21 21:45:01 +00001453 Opts.ModulesIgnoreMacros.insert(
1454 llvm::CachedHashString(MacroDef.split('=').first));
Douglas Gregor5dc38992013-02-07 00:21:12 +00001455 }
1456
Douglas Gregor9f93e382011-07-28 04:45:53 +00001457 // Add -I..., -F..., and -index-header-map options in order.
1458 bool IsIndexHeaderMap = false;
Saleem Abdulrasoolde87e5f2016-05-06 19:13:55 +00001459 bool IsSysrootSpecified =
1460 Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
Sean Silva14facf32015-06-09 01:57:17 +00001461 for (const Arg *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
1462 if (A->getOption().matches(OPT_index_header_map)) {
Douglas Gregor9f93e382011-07-28 04:45:53 +00001463 // -index-header-map applies to the next -I or -F.
1464 IsIndexHeaderMap = true;
1465 continue;
1466 }
Sean Silva14facf32015-06-09 01:57:17 +00001467
1468 frontend::IncludeDirGroup Group =
1469 IsIndexHeaderMap ? frontend::IndexHeaderMap : frontend::Angled;
1470
Saleem Abdulrasoolde87e5f2016-05-06 19:13:55 +00001471 bool IsFramework = A->getOption().matches(OPT_F);
1472 std::string Path = A->getValue();
1473
1474 if (IsSysrootSpecified && !IsFramework && A->getValue()[0] == '=') {
1475 SmallString<32> Buffer;
1476 llvm::sys::path::append(Buffer, Opts.Sysroot,
1477 llvm::StringRef(A->getValue()).substr(1));
1478 Path = Buffer.str();
1479 }
1480
Malcolm Parsonsf76f6502016-11-02 10:39:27 +00001481 Opts.AddPath(Path, Group, IsFramework,
Saleem Abdulrasoolde87e5f2016-05-06 19:13:55 +00001482 /*IgnoreSysroot*/ true);
Douglas Gregor9f93e382011-07-28 04:45:53 +00001483 IsIndexHeaderMap = false;
1484 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001485
Daniel Dunbarc9c57e92013-01-25 01:50:34 +00001486 // Add -iprefix/-iwithprefix/-iwithprefixbefore options.
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001487 StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
Sean Silva14facf32015-06-09 01:57:17 +00001488 for (const Arg *A :
1489 Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00001490 if (A->getOption().matches(OPT_iprefix))
Richard Smithbd55daf2012-11-01 04:30:05 +00001491 Prefix = A->getValue();
Daniel Dunbara442fd52010-06-11 22:00:13 +00001492 else if (A->getOption().matches(OPT_iwithprefix))
Sean Silva14facf32015-06-09 01:57:17 +00001493 Opts.AddPath(Prefix.str() + A->getValue(), frontend::After, false, true);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001494 else
Sean Silva14facf32015-06-09 01:57:17 +00001495 Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001496 }
1497
Sean Silva14facf32015-06-09 01:57:17 +00001498 for (const Arg *A : Args.filtered(OPT_idirafter))
1499 Opts.AddPath(A->getValue(), frontend::After, false, true);
1500 for (const Arg *A : Args.filtered(OPT_iquote))
1501 Opts.AddPath(A->getValue(), frontend::Quoted, false, true);
1502 for (const Arg *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
1503 Opts.AddPath(A->getValue(), frontend::System, false,
1504 !A->getOption().matches(OPT_iwithsysroot));
1505 for (const Arg *A : Args.filtered(OPT_iframework))
1506 Opts.AddPath(A->getValue(), frontend::System, true, true);
Benjamin Kramer8404eb02011-09-22 21:41:16 +00001507
1508 // Add the paths for the various language specific isystem flags.
Sean Silva14facf32015-06-09 01:57:17 +00001509 for (const Arg *A : Args.filtered(OPT_c_isystem))
1510 Opts.AddPath(A->getValue(), frontend::CSystem, false, true);
1511 for (const Arg *A : Args.filtered(OPT_cxx_isystem))
1512 Opts.AddPath(A->getValue(), frontend::CXXSystem, false, true);
1513 for (const Arg *A : Args.filtered(OPT_objc_isystem))
1514 Opts.AddPath(A->getValue(), frontend::ObjCSystem, false,true);
1515 for (const Arg *A : Args.filtered(OPT_objcxx_isystem))
1516 Opts.AddPath(A->getValue(), frontend::ObjCXXSystem, false, true);
Chandler Carruth611cb642011-11-05 08:30:29 +00001517
1518 // Add the internal paths from a driver that detects standard include paths.
Sean Silva14facf32015-06-09 01:57:17 +00001519 for (const Arg *A :
1520 Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
Daniel Dunbar9f237452013-01-30 00:19:24 +00001521 frontend::IncludeDirGroup Group = frontend::System;
Sean Silva14facf32015-06-09 01:57:17 +00001522 if (A->getOption().matches(OPT_internal_externc_isystem))
Daniel Dunbar9f237452013-01-30 00:19:24 +00001523 Group = frontend::ExternCSystem;
Sean Silva14facf32015-06-09 01:57:17 +00001524 Opts.AddPath(A->getValue(), Group, false, true);
Daniel Dunbar9f237452013-01-30 00:19:24 +00001525 }
Richard Smith8acadcb2012-06-13 20:27:03 +00001526
1527 // Add the path prefixes which are implicitly treated as being system headers.
Sean Silva14facf32015-06-09 01:57:17 +00001528 for (const Arg *A :
1529 Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
Alexander Kornienko18fa48c2014-03-26 01:39:59 +00001530 Opts.AddSystemHeaderPrefix(
Sean Silva14facf32015-06-09 01:57:17 +00001531 A->getValue(), A->getOption().matches(OPT_system_header_prefix));
Ben Langmuir801272a2014-02-25 18:23:47 +00001532
Sean Silva14facf32015-06-09 01:57:17 +00001533 for (const Arg *A : Args.filtered(OPT_ivfsoverlay))
1534 Opts.AddVFSOverlayFile(A->getValue());
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001535}
1536
Benjamin Kramera0a13c32016-08-06 11:21:04 +00001537static bool isOpenCL(LangStandard::Kind LangStd) {
Saleem Abdulrasool7de0cf32016-06-28 00:19:32 +00001538 return LangStd == LangStandard::lang_opencl ||
1539 LangStd == LangStandard::lang_opencl11 ||
1540 LangStd == LangStandard::lang_opencl12 ||
1541 LangStd == LangStandard::lang_opencl20;
Yaxun Liub5044fe2016-06-17 17:19:28 +00001542}
1543
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001544void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
Sunil Srivastavabf010802016-04-27 19:53:03 +00001545 const llvm::Triple &T,
Yaxun Liu143f0832016-06-20 19:26:00 +00001546 PreprocessorOptions &PPOpts,
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001547 LangStandard::Kind LangStd) {
Chris Lattner57540c52011-04-15 05:22:18 +00001548 // Set some properties which depend solely on the input kind; it would be nice
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001549 // to move these to the language standard, and have the driver resolve the
1550 // input kind + language standard.
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001551 if (IK == IK_Asm) {
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001552 Opts.AsmPreprocessor = 1;
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001553 } else if (IK == IK_ObjC ||
1554 IK == IK_ObjCXX ||
1555 IK == IK_PreprocessedObjC ||
1556 IK == IK_PreprocessedObjCXX) {
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001557 Opts.ObjC1 = Opts.ObjC2 = 1;
1558 }
1559
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001560 if (LangStd == LangStandard::lang_unspecified) {
1561 // Based on the base language, pick one.
1562 switch (IK) {
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001563 case IK_None:
1564 case IK_AST:
Daniel Dunbar9507f9c2010-06-07 23:26:47 +00001565 case IK_LLVM_IR:
David Blaikie83d382b2011-09-23 05:06:16 +00001566 llvm_unreachable("Invalid input kind!");
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001567 case IK_OpenCL:
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001568 LangStd = LangStandard::lang_opencl;
1569 break;
Peter Collingbourne62089b82010-12-01 03:15:20 +00001570 case IK_CUDA:
Artem Belevich83a6dcc2015-03-19 17:32:06 +00001571 case IK_PreprocessedCuda:
Peter Collingbourne62089b82010-12-01 03:15:20 +00001572 LangStd = LangStandard::lang_cuda;
1573 break;
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001574 case IK_Asm:
1575 case IK_C:
1576 case IK_PreprocessedC:
Sunil Srivastavabf010802016-04-27 19:53:03 +00001577 // The PS4 uses C99 as the default C standard.
1578 if (T.isPS4())
1579 LangStd = LangStandard::lang_gnu99;
1580 else
1581 LangStd = LangStandard::lang_gnu11;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001582 break;
Paul Robinson41a25082016-12-14 02:06:11 +00001583 case IK_ObjC:
1584 case IK_PreprocessedObjC:
1585 LangStd = LangStandard::lang_gnu11;
1586 break;
Daniel Dunbar9b491e72010-06-07 23:22:09 +00001587 case IK_CXX:
1588 case IK_PreprocessedCXX:
1589 case IK_ObjCXX:
1590 case IK_PreprocessedObjCXX:
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001591 LangStd = LangStandard::lang_gnucxx98;
1592 break;
Pirama Arumuga Nainar8b788d02016-06-09 23:34:20 +00001593 case IK_RenderScript:
1594 LangStd = LangStandard::lang_c99;
1595 break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001596 }
1597 }
1598
1599 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
Nico Weber158a31a2012-11-11 07:02:14 +00001600 Opts.LineComment = Std.hasLineComments();
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001601 Opts.C99 = Std.isC99();
Benjamin Kramere56f3932011-12-23 17:00:35 +00001602 Opts.C11 = Std.isC11();
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001603 Opts.CPlusPlus = Std.isCPlusPlus();
Richard Smith2bf7fdb2013-01-02 11:42:31 +00001604 Opts.CPlusPlus11 = Std.isCPlusPlus11();
Aaron Ballmandd69ef32014-08-19 15:55:55 +00001605 Opts.CPlusPlus14 = Std.isCPlusPlus14();
Richard Smithdbd4d4c2014-06-16 15:16:56 +00001606 Opts.CPlusPlus1z = Std.isCPlusPlus1z();
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001607 Opts.Digraphs = Std.hasDigraphs();
1608 Opts.GNUMode = Std.isGNUMode();
Peter Collingbourne470d9422015-05-13 22:07:22 +00001609 Opts.GNUInline = Std.isC89();
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001610 Opts.HexFloats = Std.hasHexFloats();
1611 Opts.ImplicitInt = Std.hasImplicitInt();
1612
Tanya Lattner79425042012-06-18 22:55:02 +00001613 // Set OpenCL Version.
Yaxun Liub5044fe2016-06-17 17:19:28 +00001614 Opts.OpenCL = isOpenCL(LangStd) || IK == IK_OpenCL;
Aaron Ballmana670c202014-05-29 16:39:42 +00001615 if (LangStd == LangStandard::lang_opencl)
Tanya Lattner79425042012-06-18 22:55:02 +00001616 Opts.OpenCLVersion = 100;
Aaron Ballmana670c202014-05-29 16:39:42 +00001617 else if (LangStd == LangStandard::lang_opencl11)
Anastasia Stulova561e0aa2014-11-20 19:25:00 +00001618 Opts.OpenCLVersion = 110;
Aaron Ballmana670c202014-05-29 16:39:42 +00001619 else if (LangStd == LangStandard::lang_opencl12)
Tanya Lattner79425042012-06-18 22:55:02 +00001620 Opts.OpenCLVersion = 120;
Anastasia Stulova561e0aa2014-11-20 19:25:00 +00001621 else if (LangStd == LangStandard::lang_opencl20)
1622 Opts.OpenCLVersion = 200;
1623
Tanya Lattner79425042012-06-18 22:55:02 +00001624 // OpenCL has some additional defaults.
1625 if (Opts.OpenCL) {
Tobias Grosser0a3a22f2011-09-21 18:28:29 +00001626 Opts.AltiVec = 0;
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00001627 Opts.ZVector = 0;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001628 Opts.CXXOperatorNames = 1;
Tobias Grosser0a3a22f2011-09-21 18:28:29 +00001629 Opts.LaxVectorConversions = 0;
Manuel Klimekff393662015-11-17 15:40:10 +00001630 Opts.DefaultFPContract = 1;
Joey Goulydd7f4562013-01-23 11:56:20 +00001631 Opts.NativeHalfType = 1;
Pirama Arumuga Nainar8e2e9d62016-03-18 16:58:36 +00001632 Opts.NativeHalfArgsAndReturns = 1;
Yaxun Liu143f0832016-06-20 19:26:00 +00001633 // Include default header file for OpenCL.
1634 if (Opts.IncludeDefaultHeader) {
1635 PPOpts.Includes.push_back("opencl-c.h");
1636 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001637 }
1638
Artem Belevich83a6dcc2015-03-19 17:32:06 +00001639 Opts.CUDA = IK == IK_CUDA || IK == IK_PreprocessedCuda ||
1640 LangStd == LangStandard::lang_cuda;
Peter Collingbourne62089b82010-12-01 03:15:20 +00001641
Pirama Arumuga Nainar8b788d02016-06-09 23:34:20 +00001642 Opts.RenderScript = IK == IK_RenderScript;
1643 if (Opts.RenderScript) {
1644 Opts.NativeHalfType = 1;
1645 Opts.NativeHalfArgsAndReturns = 1;
1646 }
1647
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001648 // OpenCL and C++ both have bool, true, false keywords.
1649 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
1650
Yunzhong Gaofcdc45f2014-03-18 17:55:18 +00001651 // OpenCL has half keyword
1652 Opts.Half = Opts.OpenCL;
1653
Abramo Bagnara73bf7f52012-09-05 17:30:57 +00001654 // C++ has wchar_t keyword.
1655 Opts.WChar = Opts.CPlusPlus;
1656
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001657 Opts.GNUKeywords = Opts.GNUMode;
1658 Opts.CXXOperatorNames = Opts.CPlusPlus;
1659
Richard Smith59139022016-09-30 22:41:36 +00001660 Opts.AlignedAllocation = Opts.CPlusPlus1z;
1661
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001662 Opts.DollarIdents = !Opts.AsmPreprocessor;
1663}
1664
John McCallb4a99d32013-02-19 01:57:35 +00001665/// Attempt to parse a visibility value out of the given argument.
1666static Visibility parseVisibility(Arg *arg, ArgList &args,
1667 DiagnosticsEngine &diags) {
1668 StringRef value = arg->getValue();
1669 if (value == "default") {
1670 return DefaultVisibility;
Reid Kleckner7737bd92015-10-21 22:01:02 +00001671 } else if (value == "hidden" || value == "internal") {
John McCallb4a99d32013-02-19 01:57:35 +00001672 return HiddenVisibility;
1673 } else if (value == "protected") {
1674 // FIXME: diagnose if target does not support protected visibility
1675 return ProtectedVisibility;
1676 }
1677
1678 diags.Report(diag::err_drv_invalid_value)
1679 << arg->getAsString(args) << value;
1680 return DefaultVisibility;
1681}
1682
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001683static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
Samuel Antao45bfe4c2016-02-08 15:59:20 +00001684 const TargetOptions &TargetOpts,
Yaxun Liu143f0832016-06-20 19:26:00 +00001685 PreprocessorOptions &PPOpts,
David Blaikie9c902b52011-09-25 23:23:43 +00001686 DiagnosticsEngine &Diags) {
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001687 // FIXME: Cleanup per-file based stuff.
1688 LangStandard::Kind LangStd = LangStandard::lang_unspecified;
1689 if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001690 LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001691#define LANGSTANDARD(id, name, desc, features) \
1692 .Case(name, LangStandard::lang_##id)
Yaxun Liub5044fe2016-06-17 17:19:28 +00001693#define LANGSTANDARD_ALIAS(id, alias) \
1694 .Case(alias, LangStandard::lang_##id)
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001695#include "clang/Frontend/LangStandards.def"
1696 .Default(LangStandard::lang_unspecified);
1697 if (LangStd == LangStandard::lang_unspecified)
1698 Diags.Report(diag::err_drv_invalid_value)
Richard Smithbd55daf2012-11-01 04:30:05 +00001699 << A->getAsString(Args) << A->getValue();
Chad Rosier24874a42011-05-02 19:24:53 +00001700 else {
Alp Tokerf6a24ce2013-12-05 16:25:25 +00001701 // Valid standard, check to make sure language and standard are
1702 // compatible.
Chad Rosier24874a42011-05-02 19:24:53 +00001703 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
1704 switch (IK) {
1705 case IK_C:
1706 case IK_ObjC:
1707 case IK_PreprocessedC:
1708 case IK_PreprocessedObjC:
1709 if (!(Std.isC89() || Std.isC99()))
1710 Diags.Report(diag::err_drv_argument_not_allowed_with)
1711 << A->getAsString(Args) << "C/ObjC";
1712 break;
1713 case IK_CXX:
1714 case IK_ObjCXX:
1715 case IK_PreprocessedCXX:
1716 case IK_PreprocessedObjCXX:
1717 if (!Std.isCPlusPlus())
1718 Diags.Report(diag::err_drv_argument_not_allowed_with)
1719 << A->getAsString(Args) << "C++/ObjC++";
1720 break;
1721 case IK_OpenCL:
Yaxun Liub5044fe2016-06-17 17:19:28 +00001722 if (!isOpenCL(LangStd))
1723 Diags.Report(diag::err_drv_argument_not_allowed_with)
1724 << A->getAsString(Args) << "OpenCL";
Chad Rosier24874a42011-05-02 19:24:53 +00001725 break;
1726 case IK_CUDA:
Artem Belevich83a6dcc2015-03-19 17:32:06 +00001727 case IK_PreprocessedCuda:
Chad Rosier24874a42011-05-02 19:24:53 +00001728 if (!Std.isCPlusPlus())
1729 Diags.Report(diag::err_drv_argument_not_allowed_with)
1730 << A->getAsString(Args) << "CUDA";
1731 break;
1732 default:
1733 break;
1734 }
1735 }
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001736 }
1737
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00001738 // -cl-std only applies for OpenCL language standards.
1739 // Override the -std option in this case.
Peter Collingbournefafa6652010-12-04 01:51:40 +00001740 if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00001741 LangStandard::Kind OpenCLLangStd
Richard Smithbd55daf2012-11-01 04:30:05 +00001742 = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
Yaxun Liub5044fe2016-06-17 17:19:28 +00001743 .Cases("cl", "CL", LangStandard::lang_opencl)
1744 .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
1745 .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
1746 .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00001747 .Default(LangStandard::lang_unspecified);
Douglas Katzman31fdbfe2015-08-05 15:08:53 +00001748
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00001749 if (OpenCLLangStd == LangStandard::lang_unspecified) {
Peter Collingbournefafa6652010-12-04 01:51:40 +00001750 Diags.Report(diag::err_drv_invalid_value)
Richard Smithbd55daf2012-11-01 04:30:05 +00001751 << A->getAsString(Args) << A->getValue();
Peter Collingbournefafa6652010-12-04 01:51:40 +00001752 }
Tanya Lattner4fdce3f2012-06-19 23:09:52 +00001753 else
1754 LangStd = OpenCLLangStd;
Peter Collingbournefafa6652010-12-04 01:51:40 +00001755 }
Douglas Katzman31fdbfe2015-08-05 15:08:53 +00001756
Yaxun Liu143f0832016-06-20 19:26:00 +00001757 Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
1758
Sunil Srivastavabf010802016-04-27 19:53:03 +00001759 llvm::Triple T(TargetOpts.Triple);
Yaxun Liu143f0832016-06-20 19:26:00 +00001760 CompilerInvocation::setLangDefaults(Opts, IK, T, PPOpts, LangStd);
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001761
Yaxun Liu02c39792016-07-13 21:21:05 +00001762 // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.
1763 // This option should be deprecated for CL > 1.0 because
1764 // this option was added for compatibility with OpenCL 1.0.
1765 if (Args.getLastArg(OPT_cl_strict_aliasing)
1766 && Opts.OpenCLVersion > 100) {
1767 std::string VerSpec = llvm::to_string(Opts.OpenCLVersion / 100) +
1768 std::string(".") +
1769 llvm::to_string((Opts.OpenCLVersion % 100) / 10);
1770 Diags.Report(diag::warn_option_invalid_ocl_version)
1771 << VerSpec << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
1772 }
1773
Chandler Carruthe03aa552010-04-17 20:17:31 +00001774 // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
1775 // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
1776 // while a subset (the non-C++ GNU keywords) is provided by GCC's
1777 // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
1778 // name, as it doesn't seem a useful distinction.
1779 Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001780 Opts.GNUKeywords);
Chandler Carruthe03aa552010-04-17 20:17:31 +00001781
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001782 if (Args.hasArg(OPT_fno_operator_names))
1783 Opts.CXXOperatorNames = 0;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001784
Reid Klecknerbbc01782014-12-03 21:53:36 +00001785 if (Args.hasArg(OPT_fcuda_is_device))
1786 Opts.CUDAIsDevice = 1;
1787
Justin Lebar1eac5942016-01-26 17:47:20 +00001788 if (Args.hasArg(OPT_fcuda_allow_variadic_functions))
1789 Opts.CUDAAllowVariadicFunctions = 1;
1790
Justin Lebarba122ab2016-03-30 23:30:21 +00001791 if (Args.hasArg(OPT_fno_cuda_host_device_constexpr))
1792 Opts.CUDAHostDeviceConstexpr = 0;
1793
Justin Lebard3a44f62016-04-05 18:26:20 +00001794 if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_flush_denormals_to_zero))
1795 Opts.CUDADeviceFlushDenormalsToZero = 1;
1796
Justin Lebar91f6f072016-05-23 20:19:56 +00001797 if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_approx_transcendentals))
1798 Opts.CUDADeviceApproxTranscendentals = 1;
1799
John McCall31168b02011-06-15 23:02:42 +00001800 if (Opts.ObjC1) {
John McCall5fb5df92012-06-20 06:18:46 +00001801 if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001802 StringRef value = arg->getValue();
John McCall5fb5df92012-06-20 06:18:46 +00001803 if (Opts.ObjCRuntime.tryParse(value))
1804 Diags.Report(diag::err_drv_unknown_objc_runtime) << value;
1805 }
1806
John McCall31168b02011-06-15 23:02:42 +00001807 if (Args.hasArg(OPT_fobjc_gc_only))
Douglas Gregor79a91412011-09-13 17:21:33 +00001808 Opts.setGC(LangOptions::GCOnly);
John McCall31168b02011-06-15 23:02:42 +00001809 else if (Args.hasArg(OPT_fobjc_gc))
Douglas Gregor79a91412011-09-13 17:21:33 +00001810 Opts.setGC(LangOptions::HybridGC);
John McCall31168b02011-06-15 23:02:42 +00001811 else if (Args.hasArg(OPT_fobjc_arc)) {
1812 Opts.ObjCAutoRefCount = 1;
John McCall3deb1ad2012-08-21 02:47:43 +00001813 if (!Opts.ObjCRuntime.allowsARC())
1814 Diags.Report(diag::err_arc_unsupported_on_runtime);
John McCall460ce582015-10-22 18:38:17 +00001815 }
John McCall31168b02011-06-15 23:02:42 +00001816
John McCall460ce582015-10-22 18:38:17 +00001817 // ObjCWeakRuntime tracks whether the runtime supports __weak, not
1818 // whether the feature is actually enabled. This is predominantly
1819 // determined by -fobjc-runtime, but we allow it to be overridden
1820 // from the command line for testing purposes.
1821 if (Args.hasArg(OPT_fobjc_runtime_has_weak))
1822 Opts.ObjCWeakRuntime = 1;
1823 else
1824 Opts.ObjCWeakRuntime = Opts.ObjCRuntime.allowsWeak();
1825
1826 // ObjCWeak determines whether __weak is actually enabled.
John McCallfbe5ed72015-11-05 19:19:56 +00001827 // Note that we allow -fno-objc-weak to disable this even in ARC mode.
1828 if (auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
1829 if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
1830 assert(!Opts.ObjCWeak);
1831 } else if (Opts.getGC() != LangOptions::NonGC) {
John McCall460ce582015-10-22 18:38:17 +00001832 Diags.Report(diag::err_objc_weak_with_gc);
John McCallfbe5ed72015-11-05 19:19:56 +00001833 } else if (!Opts.ObjCWeakRuntime) {
John McCall460ce582015-10-22 18:38:17 +00001834 Diags.Report(diag::err_objc_weak_unsupported);
John McCallfbe5ed72015-11-05 19:19:56 +00001835 } else {
1836 Opts.ObjCWeak = 1;
John McCall460ce582015-10-22 18:38:17 +00001837 }
John McCallfbe5ed72015-11-05 19:19:56 +00001838 } else if (Opts.ObjCAutoRefCount) {
1839 Opts.ObjCWeak = Opts.ObjCWeakRuntime;
John McCall3deb1ad2012-08-21 02:47:43 +00001840 }
John McCall24fc0de2011-07-06 00:26:06 +00001841
John McCall31168b02011-06-15 23:02:42 +00001842 if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
1843 Opts.ObjCInferRelatedResultType = 0;
Douglas Katzman31fdbfe2015-08-05 15:08:53 +00001844
Fariborz Jahaniane1e33f82013-11-01 21:58:17 +00001845 if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
1846 Opts.ObjCSubscriptingLegacyRuntime =
1847 (Opts.ObjCRuntime.getKind() == ObjCRuntime::FragileMacOSX);
John McCall31168b02011-06-15 23:02:42 +00001848 }
Douglas Katzman31fdbfe2015-08-05 15:08:53 +00001849
Peter Collingbourne470d9422015-05-13 22:07:22 +00001850 if (Args.hasArg(OPT_fgnu89_inline)) {
1851 if (Opts.CPlusPlus)
1852 Diags.Report(diag::err_drv_argument_not_allowed_with) << "-fgnu89-inline"
1853 << "C++/ObjC++";
1854 else
1855 Opts.GNUInline = 1;
1856 }
Rafael Espindolafb2af642011-06-02 16:13:27 +00001857
Fariborz Jahanianf7f04452011-02-04 00:01:24 +00001858 if (Args.hasArg(OPT_fapple_kext)) {
1859 if (!Opts.CPlusPlus)
1860 Diags.Report(diag::warn_c_kext);
1861 else
1862 Opts.AppleKext = 1;
1863 }
1864
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001865 if (Args.hasArg(OPT_print_ivar_layout))
1866 Opts.ObjCGCBitmapPrint = 1;
Fariborz Jahanian63408e82010-04-22 20:26:39 +00001867 if (Args.hasArg(OPT_fno_constant_cfstrings))
1868 Opts.NoConstantCFStrings = 1;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001869
1870 if (Args.hasArg(OPT_faltivec))
1871 Opts.AltiVec = 1;
1872
Ulrich Weigand3c5038a2015-07-30 14:08:36 +00001873 if (Args.hasArg(OPT_fzvector))
1874 Opts.ZVector = 1;
1875
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001876 if (Args.hasArg(OPT_pthread))
1877 Opts.POSIXThreads = 1;
1878
John McCallb4a99d32013-02-19 01:57:35 +00001879 // The value-visibility mode defaults to "default".
1880 if (Arg *visOpt = Args.getLastArg(OPT_fvisibility)) {
1881 Opts.setValueVisibilityMode(parseVisibility(visOpt, Args, Diags));
1882 } else {
1883 Opts.setValueVisibilityMode(DefaultVisibility);
1884 }
1885
1886 // The type-visibility mode defaults to the value-visibility mode.
1887 if (Arg *typeVisOpt = Args.getLastArg(OPT_ftype_visibility)) {
1888 Opts.setTypeVisibilityMode(parseVisibility(typeVisOpt, Args, Diags));
1889 } else {
1890 Opts.setTypeVisibilityMode(Opts.getValueVisibilityMode());
1891 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001892
Douglas Gregor08329632010-06-15 17:05:35 +00001893 if (Args.hasArg(OPT_fvisibility_inlines_hidden))
1894 Opts.InlineVisibilityHidden = 1;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001895
David Chisnalldd84ef12010-09-17 18:29:54 +00001896 if (Args.hasArg(OPT_ftrapv)) {
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001897 Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
David Chisnalldd84ef12010-09-17 18:29:54 +00001898 // Set the handler, if one is specified.
1899 Opts.OverflowHandler =
1900 Args.getLastArgValue(OPT_ftrapv_handler);
1901 }
Chris Lattner51924e512010-06-26 21:25:03 +00001902 else if (Args.hasArg(OPT_fwrapv))
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00001903 Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001904
Nico Weberb62ba512014-12-22 18:35:03 +00001905 Opts.MSVCCompat = Args.hasArg(OPT_fms_compatibility);
1906 Opts.MicrosoftExt = Opts.MSVCCompat || Args.hasArg(OPT_fms_extensions);
1907 Opts.AsmBlocks = Args.hasArg(OPT_fasm_blocks) || Opts.MicrosoftExt;
David Majnemerc371ff02015-03-22 08:39:22 +00001908 Opts.MSCompatibilityVersion = 0;
1909 if (const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
1910 VersionTuple VT;
1911 if (VT.tryParse(A->getValue()))
1912 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1913 << A->getValue();
1914 Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
1915 VT.getMinor().getValueOr(0) * 100000 +
1916 VT.getSubminor().getValueOr(0);
1917 }
Nico Weberb62ba512014-12-22 18:35:03 +00001918
1919 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
1920 // is specified, or -std is set to a conforming mode.
1921 // Trigraphs are disabled by default in c++1z onwards.
1922 Opts.Trigraphs = !Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus1z;
Nico Weber00721502014-12-23 22:32:37 +00001923 Opts.Trigraphs =
1924 Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001925
Daniel Dunbar15cef0e2009-12-16 20:10:18 +00001926 Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
1927 OPT_fno_dollars_in_identifiers,
Peter Collingbourneaaeb73b2010-12-04 01:50:27 +00001928 Opts.DollarIdents);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001929 Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
Reid Klecknerc0dca6d2014-02-12 23:50:26 +00001930 Opts.VtorDispMode = getLastArgIntValue(Args, OPT_vtordisp_mode_EQ, 1, Diags);
Dawn Perchik68bb1b42010-09-02 23:59:25 +00001931 Opts.Borland = Args.hasArg(OPT_fborland_extensions);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001932 Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
Chandler Carruthb009b142011-04-23 06:30:43 +00001933 Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
1934 Opts.ConstStrings);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001935 if (Args.hasArg(OPT_fno_lax_vector_conversions))
Anders Carlssonfcd764a2010-02-06 23:23:06 +00001936 Opts.LaxVectorConversions = 0;
1937 if (Args.hasArg(OPT_fno_threadsafe_statics))
Anders Carlsson5d40c6f2010-02-11 08:02:13 +00001938 Opts.ThreadsafeStatics = 0;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001939 Opts.Exceptions = Args.hasArg(OPT_fexceptions);
Anders Carlsson3320e152011-02-22 01:52:06 +00001940 Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
Anders Carlsson33e56a02011-02-23 03:16:42 +00001941 Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
1942 Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions);
David Majnemer960813e2016-02-20 09:23:47 +00001943 Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind);
Daniel Dunbar1057f862011-03-18 21:23:38 +00001944 Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
Anders Carlsson33e56a02011-02-23 03:16:42 +00001945
Yunzhong Gaobacf7e42016-01-26 20:15:02 +00001946 Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
David Majnemerf6072342014-07-01 22:24:56 +00001947 Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
Yaxun Liu18e3fd32016-06-14 21:43:01 +00001948 Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
1949 && Opts.OpenCLVersion >= 200);
John McCall7959fee2011-09-09 20:41:01 +00001950 Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
Gor Nishanov4ffb4342016-10-02 03:31:58 +00001951 Opts.CoroutinesTS = Args.hasArg(OPT_fcoroutines_ts);
Richard Smithc7bf3802016-07-23 02:32:21 +00001952 Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts);
1953 Opts.Modules = Args.hasArg(OPT_fmodules) || Opts.ModulesTS;
Daniel Jasper962b38e2014-04-11 11:47:45 +00001954 Opts.ModulesStrictDeclUse = Args.hasArg(OPT_fmodules_strict_decluse);
1955 Opts.ModulesDeclUse =
1956 Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse;
Richard Smithee977932015-05-01 21:22:17 +00001957 Opts.ModulesLocalVisibility =
Richard Smithc7bf3802016-07-23 02:32:21 +00001958 Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS;
David Blaikie9ffe5a32017-01-30 05:00:26 +00001959 Opts.ModularCodegen = Args.hasArg(OPT_fmodule_codegen);
John Thompson2255f2c2014-04-23 12:57:01 +00001960 Opts.ModulesSearchAll = Opts.Modules &&
1961 !Args.hasArg(OPT_fno_modules_search_all) &&
1962 Args.hasArg(OPT_fmodules_search_all);
Richard Smith3d23c422014-05-07 02:25:43 +00001963 Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery);
Manuel Klimekd2e8b042015-02-20 11:44:41 +00001964 Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules);
David Tweed2da64382013-09-09 09:17:24 +00001965 Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
Abramo Bagnara73bf7f52012-09-05 17:30:57 +00001966 Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
Richard Bartonc9b5f352014-02-24 18:43:28 +00001967 Opts.ShortWChar = Args.hasFlag(OPT_fshort_wchar, OPT_fno_short_wchar, false);
Argyrios Kyrtzidis74825bc2010-10-08 00:25:19 +00001968 Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001969 Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
1970 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
Chad Rosier7dbc9cf2016-01-06 14:35:46 +00001971 if (!Opts.NoBuiltin)
1972 getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
Eli Benderskyaefa5e22013-07-23 00:13:01 +00001973 Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
Richard Smith26b86ea2016-12-31 21:41:23 +00001974 Opts.RelaxedTemplateTemplateArgs =
1975 Args.hasArg(OPT_frelaxed_template_template_args);
Reid Kleckner7ffc3fb2015-03-20 00:31:07 +00001976 Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
Richard Smith59139022016-09-30 22:41:36 +00001977 Opts.AlignedAllocation =
1978 Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation,
1979 Opts.AlignedAllocation);
1980 Opts.NewAlignOverride =
1981 getLastArgIntValue(Args, OPT_fnew_alignment_EQ, 0, Diags);
1982 if (Opts.NewAlignOverride && !llvm::isPowerOf2_32(Opts.NewAlignOverride)) {
1983 Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
1984 Diags.Report(diag::err_fe_invalid_alignment) << A->getAsString(Args)
1985 << A->getValue();
1986 Opts.NewAlignOverride = 0;
1987 }
Faisal Vali24d59d12015-05-22 01:11:10 +00001988 Opts.ConceptsTS = Args.hasArg(OPT_fconcepts_ts);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001989 Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
John McCall3155f572010-04-09 19:03:51 +00001990 Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00001991 Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
David Tweed2da64382013-09-09 09:17:24 +00001992 Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
Reid Kleckner898229a2013-06-14 17:17:23 +00001993 Opts.InstantiationDepth =
Richard Smithe55b4732016-08-17 21:41:45 +00001994 getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags);
Richard Smith79c927b2013-11-06 19:31:51 +00001995 Opts.ArrowDepth =
1996 getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);
Reid Kleckner898229a2013-06-14 17:17:23 +00001997 Opts.ConstexprCallDepth =
1998 getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags);
1999 Opts.ConstexprStepLimit =
2000 getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags);
2001 Opts.BracketDepth = getLastArgIntValue(Args, OPT_fbracket_depth, 256, Diags);
Francois Pichet1c229c02011-04-22 22:18:13 +00002002 Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
Reid Kleckner898229a2013-06-14 17:17:23 +00002003 Opts.NumLargeByValueCopy =
2004 getLastArgIntValue(Args, OPT_Wlarge_by_value_copy_EQ, 0, Diags);
Douglas Gregordbe39272011-02-01 15:15:22 +00002005 Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
Daniel Dunbar37300482010-05-20 16:54:55 +00002006 Opts.ObjCConstantStringClass =
2007 Args.getLastArgValue(OPT_fconstant_string_class);
Ted Kremenek1d56c9e2010-12-23 21:35:43 +00002008 Opts.ObjCDefaultSynthProperties =
Rafael Espindolaea1ba0a2013-09-27 20:21:48 +00002009 !Args.hasArg(OPT_disable_objc_default_synthesize_properties);
Fariborz Jahanian0e3043b2012-11-15 19:02:45 +00002010 Opts.EncodeExtendedBlockSig =
2011 Args.hasArg(OPT_fencode_extended_block_signature);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002012 Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
Reid Kleckner898229a2013-06-14 17:17:23 +00002013 Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags);
Fariborz Jahanianbcd82af2014-08-05 18:37:48 +00002014 Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags);
Reid Kleckner8195f692016-05-04 02:58:24 +00002015 Opts.AlignDouble = Args.hasArg(OPT_malign_double);
Reid Kleckner898229a2013-06-14 17:17:23 +00002016 Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
Rafael Espindolac9d336e2016-06-23 15:07:32 +00002017 Opts.PIE = Args.hasArg(OPT_pic_is_pie);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002018 Opts.Static = Args.hasArg(OPT_static_define);
Douglas Gregore9fc3772012-01-26 07:55:45 +00002019 Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
Douglas Katzman31fdbfe2015-08-05 15:08:53 +00002020 Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
Douglas Gregore9fc3772012-01-26 07:55:45 +00002021 || Args.hasArg(OPT_fdump_record_layouts);
Anders Carlsson11e51402010-04-17 20:15:18 +00002022 Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
Douglas Gregor8ed0c0b2010-07-09 17:35:33 +00002023 Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
Daniel Dunbar9302f602010-04-15 15:06:22 +00002024 Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
Peter Collingbourne0b69e1a2010-12-04 01:50:56 +00002025 Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
Peter Collingbourne61d6a752010-12-04 01:51:23 +00002026 Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
Tony Linthicum76329bf2011-12-12 21:14:55 +00002027 Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
Peter Collingbourne599cb8e2011-03-18 22:38:29 +00002028 Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
John McCall39439732011-04-09 22:50:59 +00002029 Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
John McCall3f4138c2011-07-13 17:56:40 +00002030 Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
Sean Callanan1ce3a6b2012-02-04 01:29:37 +00002031 Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
Ted Kremenekf7639e12012-03-06 20:06:33 +00002032 Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
Eli Friedman055c9702011-11-02 01:53:16 +00002033 Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
Richard Smith7e82e012016-02-19 22:25:36 +00002034 Opts.CurrentModule = Args.getLastArgValue(OPT_fmodule_name_EQ);
Bob Wilsonb111ec92015-03-02 19:01:14 +00002035 Opts.AppExt = Args.hasArg(OPT_fapplication_extension);
Ben Langmuir532d2102015-02-02 21:56:15 +00002036 Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature);
Ben Langmuircd98cb72015-06-23 18:20:18 +00002037 std::sort(Opts.ModuleFeatures.begin(), Opts.ModuleFeatures.end());
Pirama Arumuga Nainare9bcddd2015-05-14 23:44:18 +00002038 Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type);
Pirama Arumuga Nainar8e2e9d62016-03-18 16:58:36 +00002039 Opts.NativeHalfArgsAndReturns |= Args.hasArg(OPT_fnative_half_arguments_and_returns);
2040 // Enable HalfArgsAndReturns if present in Args or if NativeHalfArgsAndReturns
2041 // is enabled.
2042 Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns)
2043 | Opts.NativeHalfArgsAndReturns;
Steven Wucb0d13f2015-01-16 23:05:28 +00002044 Opts.GNUAsm = !Args.hasArg(OPT_fno_gnu_inline_asm);
Ben Langmuirb537a3a2014-07-23 15:30:23 +00002045
Saleem Abdulrasoold170c4b2015-10-04 17:51:05 +00002046 // __declspec is enabled by default for the PS4 by the driver, and also
2047 // enabled for Microsoft Extensions or Borland Extensions, here.
2048 //
2049 // FIXME: __declspec is also currently enabled for CUDA, but isn't really a
Justin Lebar2dfbe9a2016-10-08 22:16:08 +00002050 // CUDA extension. However, it is required for supporting
2051 // __clang_cuda_builtin_vars.h, which uses __declspec(property). Once that has
2052 // been rewritten in terms of something more generic, remove the Opts.CUDA
2053 // term here.
Saleem Abdulrasoold170c4b2015-10-04 17:51:05 +00002054 Opts.DeclSpecKeyword =
2055 Args.hasFlag(OPT_fdeclspec, OPT_fno_declspec,
2056 (Opts.MicrosoftExt || Opts.Borland || Opts.CUDA));
2057
Richard Smith42413142015-05-15 20:05:43 +00002058 // For now, we only support local submodule visibility in C++ (because we
2059 // heavily depend on the ODR for merging redefinitions).
2060 if (Opts.ModulesLocalVisibility && !Opts.CPlusPlus)
2061 Diags.Report(diag::err_drv_argument_not_allowed_with)
2062 << "-fmodules-local-submodule-visibility" << "C";
2063
David Tweed31d09b02013-09-13 12:04:22 +00002064 if (Arg *A = Args.getLastArg(OPT_faddress_space_map_mangling_EQ)) {
2065 switch (llvm::StringSwitch<unsigned>(A->getValue())
2066 .Case("target", LangOptions::ASMM_Target)
2067 .Case("no", LangOptions::ASMM_Off)
2068 .Case("yes", LangOptions::ASMM_On)
2069 .Default(255)) {
2070 default:
Douglas Katzman31fdbfe2015-08-05 15:08:53 +00002071 Diags.Report(diag::err_drv_invalid_value)
David Tweed31d09b02013-09-13 12:04:22 +00002072 << "-faddress-space-map-mangling=" << A->getValue();
2073 break;
2074 case LangOptions::ASMM_Target:
2075 Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Target);
2076 break;
2077 case LangOptions::ASMM_On:
2078 Opts.setAddressSpaceMapMangling(LangOptions::ASMM_On);
2079 break;
2080 case LangOptions::ASMM_Off:
2081 Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Off);
2082 break;
2083 }
2084 }
2085
David Majnemer86c318f2014-02-11 21:05:00 +00002086 if (Arg *A = Args.getLastArg(OPT_fms_memptr_rep_EQ)) {
2087 LangOptions::PragmaMSPointersToMembersKind InheritanceModel =
2088 llvm::StringSwitch<LangOptions::PragmaMSPointersToMembersKind>(
2089 A->getValue())
2090 .Case("single",
2091 LangOptions::PPTMK_FullGeneralitySingleInheritance)
2092 .Case("multiple",
2093 LangOptions::PPTMK_FullGeneralityMultipleInheritance)
2094 .Case("virtual",
2095 LangOptions::PPTMK_FullGeneralityVirtualInheritance)
2096 .Default(LangOptions::PPTMK_BestCase);
2097 if (InheritanceModel == LangOptions::PPTMK_BestCase)
2098 Diags.Report(diag::err_drv_invalid_value)
2099 << "-fms-memptr-rep=" << A->getValue();
2100
2101 Opts.setMSPointerToMemberRepresentationMethod(InheritanceModel);
2102 }
2103
Alexey Bataeva7547182016-05-18 09:06:38 +00002104 // Check for MS default calling conventions being specified.
2105 if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
2106 LangOptions::DefaultCallingConvention DefaultCC =
2107 llvm::StringSwitch<LangOptions::DefaultCallingConvention>(
2108 A->getValue())
2109 .Case("cdecl", LangOptions::DCC_CDecl)
2110 .Case("fastcall", LangOptions::DCC_FastCall)
2111 .Case("stdcall", LangOptions::DCC_StdCall)
2112 .Case("vectorcall", LangOptions::DCC_VectorCall)
2113 .Default(LangOptions::DCC_None);
2114 if (DefaultCC == LangOptions::DCC_None)
2115 Diags.Report(diag::err_drv_invalid_value)
2116 << "-fdefault-calling-conv=" << A->getValue();
2117
2118 llvm::Triple T(TargetOpts.Triple);
2119 llvm::Triple::ArchType Arch = T.getArch();
2120 bool emitError = (DefaultCC == LangOptions::DCC_FastCall ||
2121 DefaultCC == LangOptions::DCC_StdCall) &&
2122 Arch != llvm::Triple::x86;
2123 emitError |= DefaultCC == LangOptions::DCC_VectorCall &&
2124 !(Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64);
2125 if (emitError)
2126 Diags.Report(diag::err_drv_argument_not_allowed_with)
2127 << A->getSpelling() << T.getTriple();
2128 else
2129 Opts.setDefaultCallingConv(DefaultCC);
2130 }
2131
2132 // -mrtd option
2133 if (Arg *A = Args.getLastArg(OPT_mrtd)) {
2134 if (Opts.getDefaultCallingConv() != LangOptions::DCC_None)
2135 Diags.Report(diag::err_drv_argument_not_allowed_with)
2136 << A->getSpelling() << "-fdefault-calling-conv";
2137 else {
2138 llvm::Triple T(TargetOpts.Triple);
2139 if (T.getArch() != llvm::Triple::x86)
2140 Diags.Report(diag::err_drv_argument_not_allowed_with)
2141 << A->getSpelling() << T.getTriple();
2142 else
2143 Opts.setDefaultCallingConv(LangOptions::DCC_StdCall);
2144 }
2145 }
2146
Alexey Bataevdb390212015-05-20 04:24:19 +00002147 // Check if -fopenmp is specified.
Alexey Bataev18c48522016-05-27 04:13:39 +00002148 Opts.OpenMP = Args.hasArg(options::OPT_fopenmp) ? 1 : 0;
Samuel Antaof8b50122015-07-13 22:54:53 +00002149 Opts.OpenMPUseTLS =
2150 Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
Samuel Antaoee8fb302016-01-06 13:42:12 +00002151 Opts.OpenMPIsDevice =
2152 Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
2153
Alexey Bataevc6bd8912016-05-26 11:10:11 +00002154 if (Opts.OpenMP) {
Alexey Bataev18c48522016-05-27 04:13:39 +00002155 int Version =
2156 getLastArgIntValue(Args, OPT_fopenmp_version_EQ, Opts.OpenMP, Diags);
2157 if (Version != 0)
Alexey Bataevc6bd8912016-05-26 11:10:11 +00002158 Opts.OpenMP = Version;
2159 // Provide diagnostic when a given target is not expected to be an OpenMP
2160 // device or host.
2161 if (!Opts.OpenMPIsDevice) {
2162 switch (T.getArch()) {
2163 default:
2164 break;
2165 // Add unsupported host targets here:
2166 case llvm::Triple::nvptx:
2167 case llvm::Triple::nvptx64:
2168 Diags.Report(clang::diag::err_drv_omp_host_target_not_supported)
2169 << TargetOpts.Triple;
2170 break;
2171 }
Samuel Antao45bfe4c2016-02-08 15:59:20 +00002172 }
2173 }
2174
Samuel Antaoee8fb302016-01-06 13:42:12 +00002175 // Get the OpenMP target triples if any.
Samuel Antao1168d63c2016-06-30 21:22:08 +00002176 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
Samuel Antaoee8fb302016-01-06 13:42:12 +00002177
2178 for (unsigned i = 0; i < A->getNumValues(); ++i) {
2179 llvm::Triple TT(A->getValue(i));
2180
2181 if (TT.getArch() == llvm::Triple::UnknownArch)
2182 Diags.Report(clang::diag::err_drv_invalid_omp_target) << A->getValue(i);
2183 else
2184 Opts.OMPTargetTriples.push_back(TT);
2185 }
2186 }
2187
2188 // Get OpenMP host file path if any and report if a non existent file is
2189 // found
Samuel Antao1168d63c2016-06-30 21:22:08 +00002190 if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
Samuel Antaoee8fb302016-01-06 13:42:12 +00002191 Opts.OMPHostIRFile = A->getValue();
2192 if (!llvm::sys::fs::exists(Opts.OMPHostIRFile))
2193 Diags.Report(clang::diag::err_drv_omp_host_ir_file_not_found)
2194 << Opts.OMPHostIRFile;
2195 }
Douglas Gregor15171282013-01-15 06:45:29 +00002196
Chandler Carruth61fbf622011-04-23 09:27:53 +00002197 // Record whether the __DEPRECATED define was requested.
2198 Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
2199 OPT_fno_deprecated_macro,
2200 Opts.Deprecated);
2201
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002202 // FIXME: Eliminate this dependency.
Dylan Noblesmith4c004f32012-08-08 16:09:15 +00002203 unsigned Opt = getOptimizationLevel(Args, IK, Diags),
Chad Rosierf2d39642013-04-10 21:30:03 +00002204 OptSize = getOptimizationLevelSize(Args);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002205 Opts.Optimize = Opt != 0;
Dylan Noblesmith4c004f32012-08-08 16:09:15 +00002206 Opts.OptimizeSize = OptSize != 0;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002207
2208 // This is the __NO_INLINE__ define, which just depends on things like the
2209 // optimization level and -fno-inline, not actually whether the backend has
2210 // inlining enabled.
Chandler Carruthfcd33142016-12-23 01:24:49 +00002211 Opts.NoInlineDefine = !Opts.Optimize;
2212 if (Arg *InlineArg = Args.getLastArg(
2213 options::OPT_finline_functions, options::OPT_finline_hint_functions,
2214 options::OPT_fno_inline_functions, options::OPT_fno_inline))
2215 if (InlineArg->getOption().matches(options::OPT_fno_inline))
2216 Opts.NoInlineDefine = true;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002217
Pekka Jaaskelainen37014502014-12-10 16:41:14 +00002218 Opts.FastMath = Args.hasArg(OPT_ffast_math) ||
2219 Args.hasArg(OPT_cl_fast_relaxed_math);
2220 Opts.FiniteMathOnly = Args.hasArg(OPT_ffinite_math_only) ||
2221 Args.hasArg(OPT_cl_finite_math_only) ||
2222 Args.hasArg(OPT_cl_fast_relaxed_math);
Alexandros Lamprineasf5a8e6c2015-10-02 14:56:37 +00002223 Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
2224 Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
2225 Args.hasArg(OPT_cl_fast_relaxed_math);
Chandler Carruth306bd2c2012-01-02 14:19:45 +00002226
Ted Kremenekb47e6bc2012-09-13 06:41:18 +00002227 Opts.RetainCommentsFromSystemHeaders =
2228 Args.hasArg(OPT_fretain_comments_from_system_headers);
2229
Reid Kleckner898229a2013-06-14 17:17:23 +00002230 unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002231 switch (SSP) {
2232 default:
2233 Diags.Report(diag::err_drv_invalid_value)
2234 << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
2235 break;
Douglas Gregor79a91412011-09-13 17:21:33 +00002236 case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
2237 case 1: Opts.setStackProtector(LangOptions::SSPOn); break;
Josh Mageee0fc1a82014-02-11 01:35:14 +00002238 case 2: Opts.setStackProtector(LangOptions::SSPStrong); break;
2239 case 3: Opts.setStackProtector(LangOptions::SSPReq); break;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002240 }
Richard Smith52be6192012-11-05 22:04:41 +00002241
2242 // Parse -fsanitize= arguments.
Alexey Samsonov88459522015-01-12 22:39:12 +00002243 parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
2244 Diags, Opts.Sanitize);
Kostya Serebryanyaed71a82014-10-09 17:53:04 +00002245 // -fsanitize-address-field-padding=N has to be a LangOpt, parse it here.
Alexey Samsonova0416102014-11-11 01:26:14 +00002246 Opts.SanitizeAddressFieldPadding =
Kostya Serebryanyaed71a82014-10-09 17:53:04 +00002247 getLastArgIntValue(Args, OPT_fsanitize_address_field_padding, 0, Diags);
Alexey Samsonova511cdd2015-02-04 17:40:08 +00002248 Opts.SanitizerBlacklistFiles = Args.getAllArgValues(OPT_fsanitize_blacklist);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002249}
2250
Daniel Dunbar6048e7f2009-12-03 05:11:16 +00002251static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002252 FileManager &FileMgr,
David Blaikie9c902b52011-09-25 23:23:43 +00002253 DiagnosticsEngine &Diags) {
James Molloya3c85b82012-05-01 14:57:16 +00002254 using namespace options;
Daniel Dunbar37300482010-05-20 16:54:55 +00002255 Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
2256 Opts.ImplicitPTHInclude = Args.getLastArgValue(OPT_include_pth);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002257 if (const Arg *A = Args.getLastArg(OPT_token_cache))
Richard Smithbd55daf2012-11-01 04:30:05 +00002258 Opts.TokenCache = A->getValue();
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002259 else
2260 Opts.TokenCache = Opts.ImplicitPTHInclude;
2261 Opts.UsePredefines = !Args.hasArg(OPT_undef);
Douglas Gregor7f6d60d2010-03-19 16:15:56 +00002262 Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
Douglas Gregorce3a8292010-07-27 00:27:13 +00002263 Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
Argyrios Kyrtzidis0427be92010-10-14 20:14:25 +00002264
Argyrios Kyrtzidisa11aca42010-10-14 20:14:18 +00002265 Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
Sean Silva14facf32015-06-09 01:57:17 +00002266 for (const Arg *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
Richard Smithbd55daf2012-11-01 04:30:05 +00002267 Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue());
Douglas Gregorce3a8292010-07-27 00:27:13 +00002268
Douglas Gregor3f4bea02010-07-26 21:36:20 +00002269 if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002270 StringRef Value(A->getValue());
Douglas Gregor3f4bea02010-07-26 21:36:20 +00002271 size_t Comma = Value.find(',');
2272 unsigned Bytes = 0;
2273 unsigned EndOfLine = 0;
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002274
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002275 if (Comma == StringRef::npos ||
Douglas Gregor3f4bea02010-07-26 21:36:20 +00002276 Value.substr(0, Comma).getAsInteger(10, Bytes) ||
2277 Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
2278 Diags.Report(diag::err_drv_preamble_format);
2279 else {
2280 Opts.PrecompiledPreambleBytes.first = Bytes;
2281 Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
2282 }
2283 }
Michael J. Spencer4c0ffa82010-10-21 03:16:25 +00002284
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002285 // Add macros from the command line.
Sean Silva14facf32015-06-09 01:57:17 +00002286 for (const Arg *A : Args.filtered(OPT_D, OPT_U)) {
2287 if (A->getOption().matches(OPT_D))
2288 Opts.addMacroDef(A->getValue());
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002289 else
Sean Silva14facf32015-06-09 01:57:17 +00002290 Opts.addMacroUndef(A->getValue());
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002291 }
2292
Daniel Dunbar37300482010-05-20 16:54:55 +00002293 Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002294
2295 // Add the ordered list of -includes.
Sean Silva14facf32015-06-09 01:57:17 +00002296 for (const Arg *A : Args.filtered(OPT_include))
Benjamin Kramer3204b152015-05-29 19:42:19 +00002297 Opts.Includes.emplace_back(A->getValue());
Daniel Dunbar6048e7f2009-12-03 05:11:16 +00002298
Sean Silva14facf32015-06-09 01:57:17 +00002299 for (const Arg *A : Args.filtered(OPT_chain_include))
Benjamin Kramer3204b152015-05-29 19:42:19 +00002300 Opts.ChainedIncludes.emplace_back(A->getValue());
Argyrios Kyrtzidis35dcda72011-03-09 17:21:42 +00002301
Sean Silva14facf32015-06-09 01:57:17 +00002302 for (const Arg *A : Args.filtered(OPT_remap_file)) {
2303 std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(';');
Daniel Dunbar6048e7f2009-12-03 05:11:16 +00002304
2305 if (Split.second.empty()) {
Daniel Dunbara442fd52010-06-11 22:00:13 +00002306 Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
Daniel Dunbar6048e7f2009-12-03 05:11:16 +00002307 continue;
2308 }
2309
2310 Opts.addRemappedFile(Split.first, Split.second);
2311 }
Sean Silva14facf32015-06-09 01:57:17 +00002312
John McCall31168b02011-06-15 23:02:42 +00002313 if (Arg *A = Args.getLastArg(OPT_fobjc_arc_cxxlib_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002314 StringRef Name = A->getValue();
John McCall31168b02011-06-15 23:02:42 +00002315 unsigned Library = llvm::StringSwitch<unsigned>(Name)
2316 .Case("libc++", ARCXX_libcxx)
2317 .Case("libstdc++", ARCXX_libstdcxx)
2318 .Case("none", ARCXX_nolib)
2319 .Default(~0U);
2320 if (Library == ~0U)
2321 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
2322 else
2323 Opts.ObjCXXARCStandardLibrary = (ObjCXXARCStandardLibraryKind)Library;
2324 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002325}
2326
2327static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
Jordan Rose17441582013-01-30 01:52:57 +00002328 ArgList &Args,
2329 frontend::ActionKind Action) {
James Molloya3c85b82012-05-01 14:57:16 +00002330 using namespace options;
Jordan Rose17441582013-01-30 01:52:57 +00002331
2332 switch (Action) {
2333 case frontend::ASTDeclList:
2334 case frontend::ASTDump:
Jordan Rose17441582013-01-30 01:52:57 +00002335 case frontend::ASTPrint:
2336 case frontend::ASTView:
2337 case frontend::EmitAssembly:
2338 case frontend::EmitBC:
2339 case frontend::EmitHTML:
2340 case frontend::EmitLLVM:
2341 case frontend::EmitLLVMOnly:
2342 case frontend::EmitCodeGenOnly:
2343 case frontend::EmitObj:
2344 case frontend::FixIt:
2345 case frontend::GenerateModule:
Richard Smithbbcc9f02016-08-26 00:14:38 +00002346 case frontend::GenerateModuleInterface:
Jordan Rose17441582013-01-30 01:52:57 +00002347 case frontend::GeneratePCH:
2348 case frontend::GeneratePTH:
2349 case frontend::ParseSyntaxOnly:
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002350 case frontend::ModuleFileInfo:
Ben Langmuir2cb4a782014-02-05 22:21:15 +00002351 case frontend::VerifyPCH:
Jordan Rose17441582013-01-30 01:52:57 +00002352 case frontend::PluginAction:
2353 case frontend::PrintDeclContext:
2354 case frontend::RewriteObjC:
2355 case frontend::RewriteTest:
2356 case frontend::RunAnalysis:
2357 case frontend::MigrateSource:
2358 Opts.ShowCPP = 0;
2359 break;
2360
2361 case frontend::DumpRawTokens:
2362 case frontend::DumpTokens:
2363 case frontend::InitOnly:
2364 case frontend::PrintPreamble:
2365 case frontend::PrintPreprocessedInput:
2366 case frontend::RewriteMacros:
2367 case frontend::RunPreprocessorOnly:
2368 Opts.ShowCPP = !Args.hasArg(OPT_dM);
2369 break;
2370 }
2371
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002372 Opts.ShowComments = Args.hasArg(OPT_C);
Daniel Dunbard4352752010-08-24 22:44:13 +00002373 Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002374 Opts.ShowMacroComments = Args.hasArg(OPT_CC);
Daniel Dunbard4352752010-08-24 22:44:13 +00002375 Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
Bruno Cardoso Lopes6fa3b742016-11-17 22:45:31 +00002376 Opts.ShowIncludeDirectives = Args.hasArg(OPT_dI);
David Blaikiee993e4c2012-06-14 17:36:09 +00002377 Opts.RewriteIncludes = Args.hasArg(OPT_frewrite_includes);
Reid Kleckner1df0fea2015-02-26 00:17:25 +00002378 Opts.UseLineDirectives = Args.hasArg(OPT_fuse_line_directives);
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002379}
2380
Saleem Abdulrasoolf7b3d6c2016-04-08 16:52:05 +00002381static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
2382 DiagnosticsEngine &Diags) {
James Molloya3c85b82012-05-01 14:57:16 +00002383 using namespace options;
Daniel Dunbar37300482010-05-20 16:54:55 +00002384 Opts.ABI = Args.getLastArgValue(OPT_target_abi);
Saleem Abdulrasoolf7b3d6c2016-04-08 16:52:05 +00002385 if (Arg *A = Args.getLastArg(OPT_meabi)) {
2386 StringRef Value = A->getValue();
2387 llvm::EABI EABIVersion = llvm::StringSwitch<llvm::EABI>(Value)
2388 .Case("default", llvm::EABI::Default)
2389 .Case("4", llvm::EABI::EABI4)
2390 .Case("5", llvm::EABI::EABI5)
2391 .Case("gnu", llvm::EABI::GNU)
2392 .Default(llvm::EABI::Unknown);
2393 if (EABIVersion == llvm::EABI::Unknown)
2394 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
2395 << Value;
2396 else
2397 Opts.EABIVersion = Value;
2398 }
Daniel Dunbar37300482010-05-20 16:54:55 +00002399 Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
Rafael Espindolaeb265472013-08-21 21:59:03 +00002400 Opts.FPMath = Args.getLastArgValue(OPT_mfpmath);
Douglas Gregorcb177f12012-10-16 23:40:58 +00002401 Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature);
Daniel Dunbara1d107c2010-08-11 23:07:42 +00002402 Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
Duncan Sandsf610b5b2010-08-30 09:42:39 +00002403 Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
Sanjay Patel2987c292015-06-11 14:53:41 +00002404 Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
Sebastian Pop8188c8a2011-11-01 21:33:06 +00002405 // Use the default target triple if unspecified.
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002406 if (Opts.Triple.empty())
Sebastian Pop8188c8a2011-11-01 21:33:06 +00002407 Opts.Triple = llvm::sys::getDefaultTargetTriple();
Alexey Bader0ea07532016-11-01 15:50:52 +00002408 Opts.OpenCLExtensionsAsWritten = Args.getAllArgValues(OPT_cl_ext_EQ);
Hans Wennborg50501fb2014-01-13 19:48:18 +00002409}
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002410
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00002411bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
Chris Lattner5159f612010-11-23 08:35:12 +00002412 const char *const *ArgBegin,
2413 const char *const *ArgEnd,
David Blaikie9c902b52011-09-25 23:23:43 +00002414 DiagnosticsEngine &Diags) {
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00002415 bool Success = true;
2416
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002417 // Parse the arguments.
David Blaikie0aaa7622017-01-13 17:34:15 +00002418 std::unique_ptr<OptTable> Opts = createDriverOptTable();
Hans Wennborgd1ddb9a2013-08-02 20:16:22 +00002419 const unsigned IncludedFlagsBitmask = options::CC1Option;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002420 unsigned MissingArgIndex, MissingArgCount;
David Blaikie69a1d8c2015-06-22 22:07:27 +00002421 InputArgList Args =
David Blaikie6d492ad2015-06-21 06:32:36 +00002422 Opts->ParseArgs(llvm::makeArrayRef(ArgBegin, ArgEnd), MissingArgIndex,
David Blaikie69a1d8c2015-06-22 22:07:27 +00002423 MissingArgCount, IncludedFlagsBitmask);
Wei Mi811ff922016-04-08 17:42:32 +00002424 LangOptions &LangOpts = *Res.getLangOpts();
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002425
2426 // Check for missing argument error.
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00002427 if (MissingArgCount) {
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002428 Diags.Report(diag::err_drv_missing_argument)
David Blaikie69a1d8c2015-06-22 22:07:27 +00002429 << Args.getArgString(MissingArgIndex) << MissingArgCount;
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00002430 Success = false;
2431 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002432
2433 // Issue errors on unknown arguments.
David Blaikie69a1d8c2015-06-22 22:07:27 +00002434 for (const Arg *A : Args.filtered(OPT_UNKNOWN)) {
2435 Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args);
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00002436 Success = false;
2437 }
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002438
David Blaikie69a1d8c2015-06-22 22:07:27 +00002439 Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags);
2440 Success &= ParseMigratorArgs(Res.getMigratorOpts(), Args);
2441 ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), Args);
Bruno Cardoso Lopes76952a72016-10-11 18:21:26 +00002442 Success &=
2443 ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags,
2444 false /*DefaultDiagColor*/, false /*DefaultShowOpt*/);
Wei Mi811ff922016-04-08 17:42:32 +00002445 ParseCommentArgs(LangOpts.CommentOpts, Args);
David Blaikie69a1d8c2015-06-22 22:07:27 +00002446 ParseFileSystemArgs(Res.getFileSystemOpts(), Args);
Peter Collingbourneb8e5dd42010-12-04 01:50:36 +00002447 // FIXME: We shouldn't have to pass the DashX option around here
Erik Verbruggene0bde752016-10-27 14:17:10 +00002448 InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags,
2449 LangOpts.IsHeaderFile);
Saleem Abdulrasoolf7b3d6c2016-04-08 16:52:05 +00002450 ParseTargetArgs(Res.getTargetOpts(), Args, Diags);
David Blaikie69a1d8c2015-06-22 22:07:27 +00002451 Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags,
Sean Silvaab70cfa2015-06-09 00:47:20 +00002452 Res.getTargetOpts());
David Blaikie69a1d8c2015-06-22 22:07:27 +00002453 ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args);
Steven Wu546a1962015-07-17 20:09:56 +00002454 if (DashX == IK_AST || DashX == IK_LLVM_IR) {
2455 // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the
2456 // PassManager in BackendUtil.cpp. They need to be initializd no matter
2457 // what the input type is.
2458 if (Args.hasArg(OPT_fobjc_arc))
Wei Mi811ff922016-04-08 17:42:32 +00002459 LangOpts.ObjCAutoRefCount = 1;
2460 // PIClevel and PIELevel are needed during code generation and this should be
2461 // set regardless of the input type.
2462 LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
Rafael Espindolac9d336e2016-06-23 15:07:32 +00002463 LangOpts.PIE = Args.hasArg(OPT_pic_is_pie);
Steven Wu546a1962015-07-17 20:09:56 +00002464 parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
Wei Mi811ff922016-04-08 17:42:32 +00002465 Diags, LangOpts.Sanitize);
Steven Wu546a1962015-07-17 20:09:56 +00002466 } else {
2467 // Other LangOpts are only initialzed when the input is not AST or LLVM IR.
Yaxun Liu143f0832016-06-20 19:26:00 +00002468 ParseLangArgs(LangOpts, Args, DashX, Res.getTargetOpts(),
2469 Res.getPreprocessorOpts(), Diags);
Fariborz Jahanian40c5e1a2011-02-25 17:24:55 +00002470 if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
Wei Mi811ff922016-04-08 17:42:32 +00002471 LangOpts.ObjCExceptions = 1;
Fariborz Jahanian40c5e1a2011-02-25 17:24:55 +00002472 }
Benjamin Kramer12f2de12016-03-14 13:23:58 +00002473
Artem Belevich31c3bad2016-05-19 18:44:45 +00002474 if (LangOpts.CUDA) {
2475 // During CUDA device-side compilation, the aux triple is the
2476 // triple used for host compilation.
2477 if (LangOpts.CUDAIsDevice)
2478 Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
2479
2480 // Set default FP_CONTRACT to FAST.
2481 if (!Args.hasArg(OPT_ffp_contract))
2482 Res.getCodeGenOpts().setFPContractMode(CodeGenOptions::FPC_Fast);
Justin Lebar76945b22016-04-29 23:05:19 +00002483 }
2484
Benjamin Kramerfd652b12016-03-15 09:41:39 +00002485 // FIXME: Override value name discarding when asan or msan is used because the
Benjamin Kramer12f2de12016-03-14 13:23:58 +00002486 // backend passes depend on the name of the alloca in order to print out
2487 // names.
Benjamin Kramerfd652b12016-03-15 09:41:39 +00002488 Res.getCodeGenOpts().DiscardValueNames &=
Wei Mi811ff922016-04-08 17:42:32 +00002489 !LangOpts.Sanitize.has(SanitizerKind::Address) &&
2490 !LangOpts.Sanitize.has(SanitizerKind::Memory);
Benjamin Kramer12f2de12016-03-14 13:23:58 +00002491
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002492 // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
2493 // PCH file and find the original header name. Remove the need to do that in
Douglas Katzman31fdbfe2015-08-05 15:08:53 +00002494 // ParsePreprocessorArgs and remove the FileManager
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +00002495 // parameters from the function and the "FileManager.h" #include.
Chris Lattner3f5a9ef2010-11-23 07:51:02 +00002496 FileManager FileMgr(Res.getFileSystemOpts());
David Blaikie69a1d8c2015-06-22 22:07:27 +00002497 ParsePreprocessorArgs(Res.getPreprocessorOpts(), Args, FileMgr, Diags);
2498 ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), Args,
Jordan Rose17441582013-01-30 01:52:57 +00002499 Res.getFrontendOpts().ProgramAction);
Yaxun Liu0bc4b2d2016-07-28 19:26:30 +00002500
2501 // Turn on -Wspir-compat for SPIR target.
2502 llvm::Triple T(Res.getTargetOpts().Triple);
2503 auto Arch = T.getArch();
2504 if (Arch == llvm::Triple::spir || Arch == llvm::Triple::spir64) {
2505 Res.getDiagnosticOpts().Warnings.push_back("spir-compat");
2506 }
Dylan Noblesmithe99b27f2011-12-23 03:05:38 +00002507 return Success;
Daniel Dunbarc70c3932009-12-01 03:16:53 +00002508}
Douglas Gregor1735f4e2011-09-13 23:15:45 +00002509
Douglas Gregor1735f4e2011-09-13 23:15:45 +00002510std::string CompilerInvocation::getModuleHash() const {
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002511 // Note: For QoI reasons, the things we use as a hash here should all be
2512 // dumped via the -module-info flag.
Douglas Gregor7fd08492012-11-05 19:45:09 +00002513 using llvm::hash_code;
2514 using llvm::hash_value;
2515 using llvm::hash_combine;
2516
Douglas Gregor1735f4e2011-09-13 23:15:45 +00002517 // Start the signature with the compiler version.
Douglas Gregordc779ab2012-11-05 23:30:26 +00002518 // FIXME: We'd rather use something more cryptographically sound than
Douglas Gregor7fd08492012-11-05 19:45:09 +00002519 // CityHash, but this will do for now.
2520 hash_code code = hash_value(getClangFullRepositoryVersion());
2521
Douglas Gregor1735f4e2011-09-13 23:15:45 +00002522 // Extend the signature with the language options
2523#define LANGOPT(Name, Bits, Default, Description) \
Douglas Gregor7fd08492012-11-05 19:45:09 +00002524 code = hash_combine(code, LangOpts->Name);
Douglas Gregor1735f4e2011-09-13 23:15:45 +00002525#define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
Douglas Gregor7fd08492012-11-05 19:45:09 +00002526 code = hash_combine(code, static_cast<unsigned>(LangOpts->get##Name()));
Douglas Gregor1735f4e2011-09-13 23:15:45 +00002527#define BENIGN_LANGOPT(Name, Bits, Default, Description)
2528#define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
2529#include "clang/Basic/LangOptions.def"
Ben Langmuircd98cb72015-06-23 18:20:18 +00002530
2531 for (StringRef Feature : LangOpts->ModuleFeatures)
2532 code = hash_combine(code, Feature);
Douglas Katzman31fdbfe2015-08-05 15:08:53 +00002533
Douglas Gregor7fd08492012-11-05 19:45:09 +00002534 // Extend the signature with the target options.
2535 code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU,
Argyrios Kyrtzidisfe6b8802014-04-29 18:45:01 +00002536 TargetOpts->ABI);
Douglas Gregor7fd08492012-11-05 19:45:09 +00002537 for (unsigned i = 0, n = TargetOpts->FeaturesAsWritten.size(); i != n; ++i)
2538 code = hash_combine(code, TargetOpts->FeaturesAsWritten[i]);
Douglas Gregor1735f4e2011-09-13 23:15:45 +00002539
Douglas Gregora739d9a2011-09-14 15:55:12 +00002540 // Extend the signature with preprocessor options.
Douglas Gregor7fd08492012-11-05 19:45:09 +00002541 const PreprocessorOptions &ppOpts = getPreprocessorOpts();
Douglas Gregor5dc38992013-02-07 00:21:12 +00002542 const HeaderSearchOptions &hsOpts = getHeaderSearchOpts();
Douglas Gregor7fd08492012-11-05 19:45:09 +00002543 code = hash_combine(code, ppOpts.UsePredefines, ppOpts.DetailedRecord);
2544
Douglas Katzman31fdbfe2015-08-05 15:08:53 +00002545 for (std::vector<std::pair<std::string, bool/*isUndef*/>>::const_iterator
Douglas Gregor71129d52011-10-17 14:55:37 +00002546 I = getPreprocessorOpts().Macros.begin(),
2547 IEnd = getPreprocessorOpts().Macros.end();
2548 I != IEnd; ++I) {
Douglas Gregor5dc38992013-02-07 00:21:12 +00002549 // If we're supposed to ignore this macro for the purposes of modules,
2550 // don't put it into the hash.
2551 if (!hsOpts.ModulesIgnoreMacros.empty()) {
Douglas Gregor5dc38992013-02-07 00:21:12 +00002552 // Check whether we're ignoring this macro.
Douglas Gregor2236c202013-02-07 01:18:48 +00002553 StringRef MacroDef = I->first;
Justin Lebar5e83dfe2016-10-21 21:45:01 +00002554 if (hsOpts.ModulesIgnoreMacros.count(
2555 llvm::CachedHashString(MacroDef.split('=').first)))
Douglas Gregor5dc38992013-02-07 00:21:12 +00002556 continue;
2557 }
2558
Douglas Gregor7fd08492012-11-05 19:45:09 +00002559 code = hash_combine(code, I->first, I->second);
Douglas Gregor71129d52011-10-17 14:55:37 +00002560 }
Douglas Gregor7fd08492012-11-05 19:45:09 +00002561
Adrian Prantl793038d32016-01-12 21:01:56 +00002562 // Extend the signature with the sysroot and other header search options.
2563 code = hash_combine(code, hsOpts.Sysroot,
2564 hsOpts.ModuleFormat,
2565 hsOpts.UseDebugInfo,
2566 hsOpts.UseBuiltinIncludes,
Douglas Gregor7fd08492012-11-05 19:45:09 +00002567 hsOpts.UseStandardSystemIncludes,
2568 hsOpts.UseStandardCXXIncludes,
Manman Ren47a44452016-07-26 17:12:17 +00002569 hsOpts.UseLibcxx,
2570 hsOpts.ModulesValidateDiagnosticOptions);
Argyrios Kyrtzidisd113788e2014-05-04 05:27:24 +00002571 code = hash_combine(code, hsOpts.ResourceDir);
Douglas Gregor7fd08492012-11-05 19:45:09 +00002572
Argyrios Kyrtzidis1594c152014-03-03 08:12:05 +00002573 // Extend the signature with the user build path.
2574 code = hash_combine(code, hsOpts.ModuleUserBuildPath);
2575
Douglas Gregor6623e1f2015-11-03 18:33:07 +00002576 // Extend the signature with the module file extensions.
2577 const FrontendOptions &frontendOpts = getFrontendOpts();
Benjamin Kramer2e018ef2016-05-27 13:36:58 +00002578 for (const auto &ext : frontendOpts.ModuleFileExtensions) {
Douglas Gregor6623e1f2015-11-03 18:33:07 +00002579 code = ext->hashExtension(code);
2580 }
2581
Douglas Gregord7193792013-05-10 21:54:08 +00002582 // Darwin-specific hack: if we have a sysroot, use the contents and
2583 // modification time of
Douglas Gregorc9be4732013-04-12 00:18:53 +00002584 // $sysroot/System/Library/CoreServices/SystemVersion.plist
2585 // as part of the module hash.
2586 if (!hsOpts.Sysroot.empty()) {
Douglas Gregorc9be4732013-04-12 00:18:53 +00002587 SmallString<128> systemVersionFile;
2588 systemVersionFile += hsOpts.Sysroot;
2589 llvm::sys::path::append(systemVersionFile, "System");
2590 llvm::sys::path::append(systemVersionFile, "Library");
2591 llvm::sys::path::append(systemVersionFile, "CoreServices");
2592 llvm::sys::path::append(systemVersionFile, "SystemVersion.plist");
Rafael Espindola2d2b4202014-07-06 17:43:24 +00002593
2594 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> buffer =
Yaron Keren92e1b622015-03-18 10:17:07 +00002595 llvm::MemoryBuffer::getFile(systemVersionFile);
Rafael Espindola2d2b4202014-07-06 17:43:24 +00002596 if (buffer) {
Douglas Gregorc9be4732013-04-12 00:18:53 +00002597 code = hash_combine(code, buffer.get()->getBuffer());
Douglas Gregord7193792013-05-10 21:54:08 +00002598
2599 struct stat statBuf;
2600 if (stat(systemVersionFile.c_str(), &statBuf) == 0)
2601 code = hash_combine(code, statBuf.st_mtime);
Douglas Gregorc9be4732013-04-12 00:18:53 +00002602 }
2603 }
2604
Douglas Gregor7fd08492012-11-05 19:45:09 +00002605 return llvm::APInt(64, code).toString(36, /*Signed=*/false);
Douglas Gregor1735f4e2011-09-13 23:15:45 +00002606}
Reid Kleckner898229a2013-06-14 17:17:23 +00002607
2608namespace clang {
2609
Dmitri Gribenkof430da42014-02-12 10:33:14 +00002610template<typename IntTy>
2611static IntTy getLastArgIntValueImpl(const ArgList &Args, OptSpecifier Id,
2612 IntTy Default,
2613 DiagnosticsEngine *Diags) {
2614 IntTy Res = Default;
Reid Kleckner898229a2013-06-14 17:17:23 +00002615 if (Arg *A = Args.getLastArg(Id)) {
2616 if (StringRef(A->getValue()).getAsInteger(10, Res)) {
2617 if (Diags)
2618 Diags->Report(diag::err_drv_invalid_int_value) << A->getAsString(Args)
2619 << A->getValue();
2620 }
2621 }
2622 return Res;
2623}
Kostya Serebryanyce2c7262013-12-27 08:11:08 +00002624
Dmitri Gribenkof430da42014-02-12 10:33:14 +00002625
2626// Declared in clang/Frontend/Utils.h.
2627int getLastArgIntValue(const ArgList &Args, OptSpecifier Id, int Default,
2628 DiagnosticsEngine *Diags) {
2629 return getLastArgIntValueImpl<int>(Args, Id, Default, Diags);
2630}
2631
2632uint64_t getLastArgUInt64Value(const ArgList &Args, OptSpecifier Id,
2633 uint64_t Default,
2634 DiagnosticsEngine *Diags) {
2635 return getLastArgIntValueImpl<uint64_t>(Args, Id, Default, Diags);
2636}
2637
Kostya Serebryanyce2c7262013-12-27 08:11:08 +00002638void BuryPointer(const void *Ptr) {
2639 // This function may be called only a small fixed amount of times per each
2640 // invocation, otherwise we do actually have a leak which we want to report.
2641 // If this function is called more than kGraveYardMaxSize times, the pointers
2642 // will not be properly buried and a leak detector will report a leak, which
2643 // is what we want in such case.
2644 static const size_t kGraveYardMaxSize = 16;
Chandler Carruth2588aa72013-12-28 02:50:00 +00002645 LLVM_ATTRIBUTE_UNUSED static const void *GraveYard[kGraveYardMaxSize];
Benjamin Kramer4527fb22014-03-02 17:08:31 +00002646 static std::atomic<unsigned> GraveYardSize;
2647 unsigned Idx = GraveYardSize++;
Kostya Serebryanyce2c7262013-12-27 08:11:08 +00002648 if (Idx >= kGraveYardMaxSize)
2649 return;
2650 GraveYard[Idx] = Ptr;
2651}
Ben Langmuir8832c062014-04-15 18:16:25 +00002652
2653IntrusiveRefCntPtr<vfs::FileSystem>
2654createVFSFromCompilerInvocation(const CompilerInvocation &CI,
2655 DiagnosticsEngine &Diags) {
2656 if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
2657 return vfs::getRealFileSystem();
2658
2659 IntrusiveRefCntPtr<vfs::OverlayFileSystem>
2660 Overlay(new vfs::OverlayFileSystem(vfs::getRealFileSystem()));
2661 // earlier vfs files are on the bottom
2662 for (const std::string &File : CI.getHeaderSearchOpts().VFSOverlayFiles) {
Rafael Espindola2d2b4202014-07-06 17:43:24 +00002663 llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
2664 llvm::MemoryBuffer::getFile(File);
2665 if (!Buffer) {
Ben Langmuir8832c062014-04-15 18:16:25 +00002666 Diags.Report(diag::err_missing_vfs_overlay_file) << File;
2667 return IntrusiveRefCntPtr<vfs::FileSystem>();
2668 }
2669
Bruno Cardoso Lopesd878e282016-03-20 02:08:48 +00002670 IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getVFSFromYAML(
2671 std::move(Buffer.get()), /*DiagHandler*/ nullptr, File);
Alp Tokerf994cef2014-07-05 03:08:06 +00002672 if (!FS.get()) {
Ben Langmuir8832c062014-04-15 18:16:25 +00002673 Diags.Report(diag::err_invalid_vfs_overlay) << File;
2674 return IntrusiveRefCntPtr<vfs::FileSystem>();
2675 }
2676 Overlay->pushOverlay(FS);
2677 }
2678 return Overlay;
Reid Kleckner898229a2013-06-14 17:17:23 +00002679}
Ben Langmuir8832c062014-04-15 18:16:25 +00002680} // end namespace clang