CompilerInvocation.cpp 115 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250125112521253125412551256125712581259126012611262126312641265126612671268126912701271127212731274127512761277127812791280128112821283128412851286128712881289129012911292129312941295129612971298129913001301130213031304130513061307130813091310131113121313131413151316131713181319132013211322132313241325132613271328132913301331133213331334133513361337133813391340134113421343134413451346134713481349135013511352135313541355135613571358135913601361136213631364136513661367136813691370137113721373137413751376137713781379138013811382138313841385138613871388138913901391139213931394139513961397139813991400140114021403140414051406140714081409141014111412141314141415141614171418141914201421142214231424142514261427142814291430143114321433143414351436143714381439144014411442144314441445144614471448144914501451145214531454145514561457145814591460146114621463146414651466146714681469147014711472147314741475147614771478147914801481148214831484148514861487148814891490149114921493149414951496149714981499150015011502150315041505150615071508150915101511151215131514151515161517151815191520152115221523152415251526152715281529153015311532153315341535153615371538153915401541154215431544154515461547154815491550155115521553155415551556155715581559156015611562156315641565156615671568156915701571157215731574157515761577157815791580158115821583158415851586158715881589159015911592159315941595159615971598159916001601160216031604160516061607160816091610161116121613161416151616161716181619162016211622162316241625162616271628162916301631163216331634163516361637163816391640164116421643164416451646164716481649165016511652165316541655165616571658165916601661166216631664166516661667166816691670167116721673167416751676167716781679168016811682168316841685168616871688168916901691169216931694169516961697169816991700170117021703170417051706170717081709171017111712171317141715171617171718171917201721172217231724172517261727172817291730173117321733173417351736173717381739174017411742174317441745174617471748174917501751175217531754175517561757175817591760176117621763176417651766176717681769177017711772177317741775177617771778177917801781178217831784178517861787178817891790179117921793179417951796179717981799180018011802180318041805180618071808180918101811181218131814181518161817181818191820182118221823182418251826182718281829183018311832183318341835183618371838183918401841184218431844184518461847184818491850185118521853185418551856185718581859186018611862186318641865186618671868186918701871187218731874187518761877187818791880188118821883188418851886188718881889189018911892189318941895189618971898189919001901190219031904190519061907190819091910191119121913191419151916191719181919192019211922192319241925192619271928192919301931193219331934193519361937193819391940194119421943194419451946194719481949195019511952195319541955195619571958195919601961196219631964196519661967196819691970197119721973197419751976197719781979198019811982198319841985198619871988198919901991199219931994199519961997199819992000200120022003200420052006200720082009201020112012201320142015201620172018201920202021202220232024202520262027202820292030203120322033203420352036203720382039204020412042204320442045204620472048204920502051205220532054205520562057205820592060206120622063206420652066206720682069207020712072207320742075207620772078207920802081208220832084208520862087208820892090209120922093209420952096209720982099210021012102210321042105210621072108210921102111211221132114211521162117211821192120212121222123212421252126212721282129213021312132213321342135213621372138213921402141214221432144214521462147214821492150215121522153215421552156215721582159216021612162216321642165216621672168216921702171217221732174217521762177217821792180218121822183218421852186218721882189219021912192219321942195219621972198219922002201220222032204220522062207220822092210221122122213221422152216221722182219222022212222222322242225222622272228222922302231223222332234223522362237223822392240224122422243224422452246224722482249225022512252225322542255225622572258225922602261226222632264226522662267226822692270227122722273227422752276227722782279228022812282228322842285228622872288228922902291229222932294229522962297229822992300230123022303230423052306230723082309231023112312231323142315231623172318231923202321232223232324232523262327232823292330233123322333233423352336233723382339234023412342234323442345234623472348234923502351235223532354235523562357235823592360236123622363236423652366236723682369237023712372237323742375237623772378237923802381238223832384238523862387238823892390239123922393239423952396239723982399240024012402240324042405240624072408240924102411241224132414241524162417241824192420242124222423242424252426242724282429243024312432243324342435243624372438243924402441244224432444244524462447244824492450245124522453245424552456245724582459246024612462246324642465246624672468246924702471247224732474247524762477247824792480248124822483248424852486248724882489249024912492249324942495249624972498249925002501250225032504250525062507250825092510251125122513251425152516251725182519252025212522252325242525252625272528252925302531253225332534253525362537253825392540254125422543254425452546254725482549255025512552255325542555255625572558255925602561256225632564256525662567256825692570257125722573257425752576257725782579258025812582258325842585258625872588258925902591259225932594259525962597259825992600260126022603260426052606260726082609261026112612261326142615261626172618261926202621262226232624262526262627262826292630263126322633263426352636263726382639264026412642264326442645264626472648264926502651265226532654265526562657265826592660266126622663266426652666266726682669267026712672267326742675267626772678267926802681268226832684268526862687268826892690269126922693269426952696269726982699270027012702270327042705270627072708270927102711271227132714271527162717271827192720272127222723272427252726272727282729273027312732273327342735273627372738273927402741274227432744274527462747274827492750275127522753275427552756275727582759276027612762276327642765276627672768276927702771277227732774277527762777277827792780278127822783278427852786278727882789279027912792279327942795279627972798279928002801280228032804280528062807280828092810281128122813281428152816281728182819282028212822282328242825282628272828282928302831283228332834283528362837283828392840284128422843284428452846284728482849
  1. //===--- CompilerInvocation.cpp -------------------------------------------===//
  2. //
  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. #include "clang/Frontend/CompilerInvocation.h"
  10. #include "TestModuleFileExtension.h"
  11. #include "clang/Basic/Builtins.h"
  12. #include "clang/Basic/FileManager.h"
  13. #include "clang/Basic/Version.h"
  14. #include "clang/Config/config.h"
  15. #include "clang/Driver/DriverDiagnostic.h"
  16. #include "clang/Driver/Options.h"
  17. #include "clang/Driver/Util.h"
  18. #include "clang/Frontend/FrontendDiagnostic.h"
  19. #include "clang/Frontend/LangStandard.h"
  20. #include "clang/Frontend/Utils.h"
  21. #include "clang/Lex/HeaderSearchOptions.h"
  22. #include "clang/Lex/PreprocessorOptions.h"
  23. #include "clang/Serialization/ASTReader.h"
  24. #include "clang/Serialization/ModuleFileExtension.h"
  25. #include "llvm/ADT/Hashing.h"
  26. #include "llvm/ADT/STLExtras.h"
  27. #include "llvm/ADT/SmallVector.h"
  28. #include "llvm/ADT/StringExtras.h"
  29. #include "llvm/ADT/StringSwitch.h"
  30. #include "llvm/ADT/Triple.h"
  31. #include "llvm/Linker/Linker.h"
  32. #include "llvm/Option/Arg.h"
  33. #include "llvm/Option/ArgList.h"
  34. #include "llvm/Option/OptTable.h"
  35. #include "llvm/Option/Option.h"
  36. #include "llvm/ProfileData/InstrProfReader.h"
  37. #include "llvm/Support/CodeGen.h"
  38. #include "llvm/Support/ErrorHandling.h"
  39. #include "llvm/Support/FileSystem.h"
  40. #include "llvm/Support/Host.h"
  41. #include "llvm/Support/Path.h"
  42. #include "llvm/Support/Process.h"
  43. #include "llvm/Target/TargetOptions.h"
  44. #include "llvm/Support/ScopedPrinter.h"
  45. #include <atomic>
  46. #include <memory>
  47. #include <sys/stat.h>
  48. #include <system_error>
  49. using namespace clang;
  50. //===----------------------------------------------------------------------===//
  51. // Initialization.
  52. //===----------------------------------------------------------------------===//
  53. CompilerInvocationBase::CompilerInvocationBase()
  54. : LangOpts(new LangOptions()), TargetOpts(new TargetOptions()),
  55. DiagnosticOpts(new DiagnosticOptions()),
  56. HeaderSearchOpts(new HeaderSearchOptions()),
  57. PreprocessorOpts(new PreprocessorOptions()) {}
  58. CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &X)
  59. : LangOpts(new LangOptions(*X.getLangOpts())),
  60. TargetOpts(new TargetOptions(X.getTargetOpts())),
  61. DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
  62. HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
  63. PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())) {}
  64. CompilerInvocationBase::~CompilerInvocationBase() {}
  65. //===----------------------------------------------------------------------===//
  66. // Deserialization (from args)
  67. //===----------------------------------------------------------------------===//
  68. using namespace clang::driver;
  69. using namespace clang::driver::options;
  70. using namespace llvm::opt;
  71. //
  72. static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
  73. DiagnosticsEngine &Diags) {
  74. unsigned DefaultOpt = 0;
  75. if (IK.getLanguage() == InputKind::OpenCL && !Args.hasArg(OPT_cl_opt_disable))
  76. DefaultOpt = 2;
  77. if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
  78. if (A->getOption().matches(options::OPT_O0))
  79. return 0;
  80. if (A->getOption().matches(options::OPT_Ofast))
  81. return 3;
  82. assert (A->getOption().matches(options::OPT_O));
  83. StringRef S(A->getValue());
  84. if (S == "s" || S == "z" || S.empty())
  85. return 2;
  86. if (S == "g")
  87. return 1;
  88. return getLastArgIntValue(Args, OPT_O, DefaultOpt, Diags);
  89. }
  90. return DefaultOpt;
  91. }
  92. static unsigned getOptimizationLevelSize(ArgList &Args) {
  93. if (Arg *A = Args.getLastArg(options::OPT_O_Group)) {
  94. if (A->getOption().matches(options::OPT_O)) {
  95. switch (A->getValue()[0]) {
  96. default:
  97. return 0;
  98. case 's':
  99. return 1;
  100. case 'z':
  101. return 2;
  102. }
  103. }
  104. }
  105. return 0;
  106. }
  107. static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group,
  108. OptSpecifier GroupWithValue,
  109. std::vector<std::string> &Diagnostics) {
  110. for (Arg *A : Args.filtered(Group)) {
  111. if (A->getOption().getKind() == Option::FlagClass) {
  112. // The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add
  113. // its name (minus the "W" or "R" at the beginning) to the warning list.
  114. Diagnostics.push_back(A->getOption().getName().drop_front(1));
  115. } else if (A->getOption().matches(GroupWithValue)) {
  116. // This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic group.
  117. Diagnostics.push_back(A->getOption().getName().drop_front(1).rtrim("=-"));
  118. } else {
  119. // Otherwise, add its value (for OPT_W_Joined and similar).
  120. for (const char *Arg : A->getValues())
  121. Diagnostics.emplace_back(Arg);
  122. }
  123. }
  124. }
  125. static void getAllNoBuiltinFuncValues(ArgList &Args,
  126. std::vector<std::string> &Funcs) {
  127. SmallVector<const char *, 8> Values;
  128. for (const auto &Arg : Args) {
  129. const Option &O = Arg->getOption();
  130. if (O.matches(options::OPT_fno_builtin_)) {
  131. const char *FuncName = Arg->getValue();
  132. if (Builtin::Context::isBuiltinFunc(FuncName))
  133. Values.push_back(FuncName);
  134. }
  135. }
  136. Funcs.insert(Funcs.end(), Values.begin(), Values.end());
  137. }
  138. static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
  139. DiagnosticsEngine &Diags) {
  140. using namespace options;
  141. bool Success = true;
  142. if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
  143. StringRef Name = A->getValue();
  144. AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
  145. #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
  146. .Case(CMDFLAG, NAME##Model)
  147. #include "clang/StaticAnalyzer/Core/Analyses.def"
  148. .Default(NumStores);
  149. if (Value == NumStores) {
  150. Diags.Report(diag::err_drv_invalid_value)
  151. << A->getAsString(Args) << Name;
  152. Success = false;
  153. } else {
  154. Opts.AnalysisStoreOpt = Value;
  155. }
  156. }
  157. if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
  158. StringRef Name = A->getValue();
  159. AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
  160. #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
  161. .Case(CMDFLAG, NAME##Model)
  162. #include "clang/StaticAnalyzer/Core/Analyses.def"
  163. .Default(NumConstraints);
  164. if (Value == NumConstraints) {
  165. Diags.Report(diag::err_drv_invalid_value)
  166. << A->getAsString(Args) << Name;
  167. Success = false;
  168. } else {
  169. Opts.AnalysisConstraintsOpt = Value;
  170. }
  171. }
  172. if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
  173. StringRef Name = A->getValue();
  174. AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
  175. #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN) \
  176. .Case(CMDFLAG, PD_##NAME)
  177. #include "clang/StaticAnalyzer/Core/Analyses.def"
  178. .Default(NUM_ANALYSIS_DIAG_CLIENTS);
  179. if (Value == NUM_ANALYSIS_DIAG_CLIENTS) {
  180. Diags.Report(diag::err_drv_invalid_value)
  181. << A->getAsString(Args) << Name;
  182. Success = false;
  183. } else {
  184. Opts.AnalysisDiagOpt = Value;
  185. }
  186. }
  187. if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
  188. StringRef Name = A->getValue();
  189. AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name)
  190. #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
  191. .Case(CMDFLAG, NAME)
  192. #include "clang/StaticAnalyzer/Core/Analyses.def"
  193. .Default(NumPurgeModes);
  194. if (Value == NumPurgeModes) {
  195. Diags.Report(diag::err_drv_invalid_value)
  196. << A->getAsString(Args) << Name;
  197. Success = false;
  198. } else {
  199. Opts.AnalysisPurgeOpt = Value;
  200. }
  201. }
  202. if (Arg *A = Args.getLastArg(OPT_analyzer_inlining_mode)) {
  203. StringRef Name = A->getValue();
  204. AnalysisInliningMode Value = llvm::StringSwitch<AnalysisInliningMode>(Name)
  205. #define ANALYSIS_INLINING_MODE(NAME, CMDFLAG, DESC) \
  206. .Case(CMDFLAG, NAME)
  207. #include "clang/StaticAnalyzer/Core/Analyses.def"
  208. .Default(NumInliningModes);
  209. if (Value == NumInliningModes) {
  210. Diags.Report(diag::err_drv_invalid_value)
  211. << A->getAsString(Args) << Name;
  212. Success = false;
  213. } else {
  214. Opts.InliningMode = Value;
  215. }
  216. }
  217. Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
  218. Opts.ShowEnabledCheckerList = Args.hasArg(OPT_analyzer_list_enabled_checkers);
  219. Opts.DisableAllChecks = Args.hasArg(OPT_analyzer_disable_all_checks);
  220. Opts.visualizeExplodedGraphWithGraphViz =
  221. Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
  222. Opts.visualizeExplodedGraphWithUbiGraph =
  223. Args.hasArg(OPT_analyzer_viz_egraph_ubigraph);
  224. Opts.NoRetryExhausted = Args.hasArg(OPT_analyzer_disable_retry_exhausted);
  225. Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
  226. Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
  227. Opts.AnalyzeNestedBlocks =
  228. Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
  229. Opts.eagerlyAssumeBinOpBifurcation = Args.hasArg(OPT_analyzer_eagerly_assume);
  230. Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
  231. Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
  232. Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
  233. Opts.maxBlockVisitOnPath =
  234. getLastArgIntValue(Args, OPT_analyzer_max_loop, 4, Diags);
  235. Opts.PrintStats = Args.hasArg(OPT_analyzer_stats);
  236. Opts.InlineMaxStackDepth =
  237. getLastArgIntValue(Args, OPT_analyzer_inline_max_stack_depth,
  238. Opts.InlineMaxStackDepth, Diags);
  239. Opts.CheckersControlList.clear();
  240. for (const Arg *A :
  241. Args.filtered(OPT_analyzer_checker, OPT_analyzer_disable_checker)) {
  242. A->claim();
  243. bool enable = (A->getOption().getID() == OPT_analyzer_checker);
  244. // We can have a list of comma separated checker names, e.g:
  245. // '-analyzer-checker=cocoa,unix'
  246. StringRef checkerList = A->getValue();
  247. SmallVector<StringRef, 4> checkers;
  248. checkerList.split(checkers, ",");
  249. for (StringRef checker : checkers)
  250. Opts.CheckersControlList.emplace_back(checker, enable);
  251. }
  252. // Go through the analyzer configuration options.
  253. for (const Arg *A : Args.filtered(OPT_analyzer_config)) {
  254. A->claim();
  255. // We can have a list of comma separated config names, e.g:
  256. // '-analyzer-config key1=val1,key2=val2'
  257. StringRef configList = A->getValue();
  258. SmallVector<StringRef, 4> configVals;
  259. configList.split(configVals, ",");
  260. for (unsigned i = 0, e = configVals.size(); i != e; ++i) {
  261. StringRef key, val;
  262. std::tie(key, val) = configVals[i].split("=");
  263. if (val.empty()) {
  264. Diags.Report(SourceLocation(),
  265. diag::err_analyzer_config_no_value) << configVals[i];
  266. Success = false;
  267. break;
  268. }
  269. if (val.find('=') != StringRef::npos) {
  270. Diags.Report(SourceLocation(),
  271. diag::err_analyzer_config_multiple_values)
  272. << configVals[i];
  273. Success = false;
  274. break;
  275. }
  276. Opts.Config[key] = val;
  277. }
  278. }
  279. return Success;
  280. }
  281. static bool ParseMigratorArgs(MigratorOptions &Opts, ArgList &Args) {
  282. Opts.NoNSAllocReallocError = Args.hasArg(OPT_migrator_no_nsalloc_error);
  283. Opts.NoFinalizeRemoval = Args.hasArg(OPT_migrator_no_finalize_removal);
  284. return true;
  285. }
  286. static void ParseCommentArgs(CommentOptions &Opts, ArgList &Args) {
  287. Opts.BlockCommandNames = Args.getAllArgValues(OPT_fcomment_block_commands);
  288. Opts.ParseAllComments = Args.hasArg(OPT_fparse_all_comments);
  289. }
  290. static StringRef getCodeModel(ArgList &Args, DiagnosticsEngine &Diags) {
  291. if (Arg *A = Args.getLastArg(OPT_mcode_model)) {
  292. StringRef Value = A->getValue();
  293. if (Value == "small" || Value == "kernel" || Value == "medium" ||
  294. Value == "large")
  295. return Value;
  296. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Value;
  297. }
  298. return "default";
  299. }
  300. static StringRef getRelocModel(ArgList &Args, DiagnosticsEngine &Diags) {
  301. if (Arg *A = Args.getLastArg(OPT_mrelocation_model)) {
  302. StringRef Value = A->getValue();
  303. if (Value == "static" || Value == "pic" || Value == "ropi" ||
  304. Value == "rwpi" || Value == "ropi-rwpi" || Value == "dynamic-no-pic")
  305. return Value;
  306. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Value;
  307. }
  308. return "pic";
  309. }
  310. /// \brief Create a new Regex instance out of the string value in \p RpassArg.
  311. /// It returns a pointer to the newly generated Regex instance.
  312. static std::shared_ptr<llvm::Regex>
  313. GenerateOptimizationRemarkRegex(DiagnosticsEngine &Diags, ArgList &Args,
  314. Arg *RpassArg) {
  315. StringRef Val = RpassArg->getValue();
  316. std::string RegexError;
  317. std::shared_ptr<llvm::Regex> Pattern = std::make_shared<llvm::Regex>(Val);
  318. if (!Pattern->isValid(RegexError)) {
  319. Diags.Report(diag::err_drv_optimization_remark_pattern)
  320. << RegexError << RpassArg->getAsString(Args);
  321. Pattern.reset();
  322. }
  323. return Pattern;
  324. }
  325. static bool parseDiagnosticLevelMask(StringRef FlagName,
  326. const std::vector<std::string> &Levels,
  327. DiagnosticsEngine *Diags,
  328. DiagnosticLevelMask &M) {
  329. bool Success = true;
  330. for (const auto &Level : Levels) {
  331. DiagnosticLevelMask const PM =
  332. llvm::StringSwitch<DiagnosticLevelMask>(Level)
  333. .Case("note", DiagnosticLevelMask::Note)
  334. .Case("remark", DiagnosticLevelMask::Remark)
  335. .Case("warning", DiagnosticLevelMask::Warning)
  336. .Case("error", DiagnosticLevelMask::Error)
  337. .Default(DiagnosticLevelMask::None);
  338. if (PM == DiagnosticLevelMask::None) {
  339. Success = false;
  340. if (Diags)
  341. Diags->Report(diag::err_drv_invalid_value) << FlagName << Level;
  342. }
  343. M = M | PM;
  344. }
  345. return Success;
  346. }
  347. static void parseSanitizerKinds(StringRef FlagName,
  348. const std::vector<std::string> &Sanitizers,
  349. DiagnosticsEngine &Diags, SanitizerSet &S) {
  350. for (const auto &Sanitizer : Sanitizers) {
  351. SanitizerMask K = parseSanitizerValue(Sanitizer, /*AllowGroups=*/false);
  352. if (K == 0)
  353. Diags.Report(diag::err_drv_invalid_value) << FlagName << Sanitizer;
  354. else
  355. S.set(K, true);
  356. }
  357. }
  358. // Set the profile kind for fprofile-instrument.
  359. static void setPGOInstrumentor(CodeGenOptions &Opts, ArgList &Args,
  360. DiagnosticsEngine &Diags) {
  361. Arg *A = Args.getLastArg(OPT_fprofile_instrument_EQ);
  362. if (A == nullptr)
  363. return;
  364. StringRef S = A->getValue();
  365. unsigned I = llvm::StringSwitch<unsigned>(S)
  366. .Case("none", CodeGenOptions::ProfileNone)
  367. .Case("clang", CodeGenOptions::ProfileClangInstr)
  368. .Case("llvm", CodeGenOptions::ProfileIRInstr)
  369. .Default(~0U);
  370. if (I == ~0U) {
  371. Diags.Report(diag::err_drv_invalid_pgo_instrumentor) << A->getAsString(Args)
  372. << S;
  373. return;
  374. }
  375. CodeGenOptions::ProfileInstrKind Instrumentor =
  376. static_cast<CodeGenOptions::ProfileInstrKind>(I);
  377. Opts.setProfileInstr(Instrumentor);
  378. }
  379. // Set the profile kind using fprofile-instrument-use-path.
  380. static void setPGOUseInstrumentor(CodeGenOptions &Opts,
  381. const Twine &ProfileName) {
  382. auto ReaderOrErr = llvm::IndexedInstrProfReader::create(ProfileName);
  383. // In error, return silently and let Clang PGOUse report the error message.
  384. if (auto E = ReaderOrErr.takeError()) {
  385. llvm::consumeError(std::move(E));
  386. Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
  387. return;
  388. }
  389. std::unique_ptr<llvm::IndexedInstrProfReader> PGOReader =
  390. std::move(ReaderOrErr.get());
  391. if (PGOReader->isIRLevelProfile())
  392. Opts.setProfileUse(CodeGenOptions::ProfileIRInstr);
  393. else
  394. Opts.setProfileUse(CodeGenOptions::ProfileClangInstr);
  395. }
  396. static bool ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
  397. DiagnosticsEngine &Diags,
  398. const TargetOptions &TargetOpts) {
  399. using namespace options;
  400. bool Success = true;
  401. llvm::Triple Triple = llvm::Triple(TargetOpts.Triple);
  402. unsigned OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
  403. // TODO: This could be done in Driver
  404. unsigned MaxOptLevel = 3;
  405. if (OptimizationLevel > MaxOptLevel) {
  406. // If the optimization level is not supported, fall back on the default
  407. // optimization
  408. Diags.Report(diag::warn_drv_optimization_value)
  409. << Args.getLastArg(OPT_O)->getAsString(Args) << "-O" << MaxOptLevel;
  410. OptimizationLevel = MaxOptLevel;
  411. }
  412. Opts.OptimizationLevel = OptimizationLevel;
  413. // At O0 we want to fully disable inlining outside of cases marked with
  414. // 'alwaysinline' that are required for correctness.
  415. Opts.setInlining((Opts.OptimizationLevel == 0)
  416. ? CodeGenOptions::OnlyAlwaysInlining
  417. : CodeGenOptions::NormalInlining);
  418. // Explicit inlining flags can disable some or all inlining even at
  419. // optimization levels above zero.
  420. if (Arg *InlineArg = Args.getLastArg(
  421. options::OPT_finline_functions, options::OPT_finline_hint_functions,
  422. options::OPT_fno_inline_functions, options::OPT_fno_inline)) {
  423. if (Opts.OptimizationLevel > 0) {
  424. const Option &InlineOpt = InlineArg->getOption();
  425. if (InlineOpt.matches(options::OPT_finline_functions))
  426. Opts.setInlining(CodeGenOptions::NormalInlining);
  427. else if (InlineOpt.matches(options::OPT_finline_hint_functions))
  428. Opts.setInlining(CodeGenOptions::OnlyHintInlining);
  429. else
  430. Opts.setInlining(CodeGenOptions::OnlyAlwaysInlining);
  431. }
  432. }
  433. Opts.ExperimentalNewPassManager = Args.hasFlag(
  434. OPT_fexperimental_new_pass_manager, OPT_fno_experimental_new_pass_manager,
  435. /* Default */ false);
  436. Opts.DebugPassManager =
  437. Args.hasFlag(OPT_fdebug_pass_manager, OPT_fno_debug_pass_manager,
  438. /* Default */ false);
  439. if (Arg *A = Args.getLastArg(OPT_fveclib)) {
  440. StringRef Name = A->getValue();
  441. if (Name == "Accelerate")
  442. Opts.setVecLib(CodeGenOptions::Accelerate);
  443. else if (Name == "SVML")
  444. Opts.setVecLib(CodeGenOptions::SVML);
  445. else if (Name == "none")
  446. Opts.setVecLib(CodeGenOptions::NoLibrary);
  447. else
  448. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
  449. }
  450. if (Arg *A = Args.getLastArg(OPT_debug_info_kind_EQ)) {
  451. unsigned Val =
  452. llvm::StringSwitch<unsigned>(A->getValue())
  453. .Case("line-tables-only", codegenoptions::DebugLineTablesOnly)
  454. .Case("limited", codegenoptions::LimitedDebugInfo)
  455. .Case("standalone", codegenoptions::FullDebugInfo)
  456. .Default(~0U);
  457. if (Val == ~0U)
  458. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
  459. << A->getValue();
  460. else
  461. Opts.setDebugInfo(static_cast<codegenoptions::DebugInfoKind>(Val));
  462. }
  463. if (Arg *A = Args.getLastArg(OPT_debugger_tuning_EQ)) {
  464. unsigned Val = llvm::StringSwitch<unsigned>(A->getValue())
  465. .Case("gdb", unsigned(llvm::DebuggerKind::GDB))
  466. .Case("lldb", unsigned(llvm::DebuggerKind::LLDB))
  467. .Case("sce", unsigned(llvm::DebuggerKind::SCE))
  468. .Default(~0U);
  469. if (Val == ~0U)
  470. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
  471. << A->getValue();
  472. else
  473. Opts.setDebuggerTuning(static_cast<llvm::DebuggerKind>(Val));
  474. }
  475. Opts.DwarfVersion = getLastArgIntValue(Args, OPT_dwarf_version_EQ, 0, Diags);
  476. Opts.DebugColumnInfo = Args.hasArg(OPT_dwarf_column_info);
  477. Opts.EmitCodeView = Args.hasArg(OPT_gcodeview);
  478. Opts.MacroDebugInfo = Args.hasArg(OPT_debug_info_macro);
  479. Opts.WholeProgramVTables = Args.hasArg(OPT_fwhole_program_vtables);
  480. Opts.LTOVisibilityPublicStd = Args.hasArg(OPT_flto_visibility_public_std);
  481. Opts.EnableSplitDwarf = Args.hasArg(OPT_enable_split_dwarf);
  482. Opts.SplitDwarfFile = Args.getLastArgValue(OPT_split_dwarf_file);
  483. Opts.SplitDwarfInlining = !Args.hasArg(OPT_fno_split_dwarf_inlining);
  484. Opts.DebugTypeExtRefs = Args.hasArg(OPT_dwarf_ext_refs);
  485. Opts.DebugExplicitImport = Triple.isPS4CPU();
  486. for (const auto &Arg : Args.getAllArgValues(OPT_fdebug_prefix_map_EQ))
  487. Opts.DebugPrefixMap.insert(StringRef(Arg).split('='));
  488. if (const Arg *A =
  489. Args.getLastArg(OPT_emit_llvm_uselists, OPT_no_emit_llvm_uselists))
  490. Opts.EmitLLVMUseLists = A->getOption().getID() == OPT_emit_llvm_uselists;
  491. Opts.DisableLLVMPasses = Args.hasArg(OPT_disable_llvm_passes);
  492. Opts.DisableLifetimeMarkers = Args.hasArg(OPT_disable_lifetimemarkers);
  493. Opts.DisableO0ImplyOptNone = Args.hasArg(OPT_disable_O0_optnone);
  494. Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
  495. Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
  496. Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
  497. OPT_fuse_register_sized_bitfield_access);
  498. Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
  499. Opts.StructPathTBAA = !Args.hasArg(OPT_no_struct_path_tbaa);
  500. Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
  501. Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
  502. Opts.NoCommon = Args.hasArg(OPT_fno_common);
  503. Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
  504. Opts.OptimizeSize = getOptimizationLevelSize(Args);
  505. Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
  506. Args.hasArg(OPT_ffreestanding));
  507. if (Opts.SimplifyLibCalls)
  508. getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
  509. Opts.UnrollLoops =
  510. Args.hasFlag(OPT_funroll_loops, OPT_fno_unroll_loops,
  511. (Opts.OptimizationLevel > 1));
  512. Opts.RerollLoops = Args.hasArg(OPT_freroll_loops);
  513. Opts.DisableIntegratedAS = Args.hasArg(OPT_fno_integrated_as);
  514. Opts.Autolink = !Args.hasArg(OPT_fno_autolink);
  515. Opts.SampleProfileFile = Args.getLastArgValue(OPT_fprofile_sample_use_EQ);
  516. Opts.DebugInfoForProfiling = Args.hasFlag(
  517. OPT_fdebug_info_for_profiling, OPT_fno_debug_info_for_profiling, false);
  518. setPGOInstrumentor(Opts, Args, Diags);
  519. Opts.InstrProfileOutput =
  520. Args.getLastArgValue(OPT_fprofile_instrument_path_EQ);
  521. Opts.ProfileInstrumentUsePath =
  522. Args.getLastArgValue(OPT_fprofile_instrument_use_path_EQ);
  523. if (!Opts.ProfileInstrumentUsePath.empty())
  524. setPGOUseInstrumentor(Opts, Opts.ProfileInstrumentUsePath);
  525. Opts.CoverageMapping =
  526. Args.hasFlag(OPT_fcoverage_mapping, OPT_fno_coverage_mapping, false);
  527. Opts.DumpCoverageMapping = Args.hasArg(OPT_dump_coverage_mapping);
  528. Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
  529. Opts.PreserveAsmComments = !Args.hasArg(OPT_fno_preserve_as_comments);
  530. Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
  531. Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
  532. Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
  533. Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
  534. Opts.CodeModel = getCodeModel(Args, Diags);
  535. Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
  536. Opts.DisableFPElim =
  537. (Args.hasArg(OPT_mdisable_fp_elim) || Args.hasArg(OPT_pg));
  538. Opts.DisableFree = Args.hasArg(OPT_disable_free);
  539. Opts.DiscardValueNames = Args.hasArg(OPT_discard_value_names);
  540. Opts.DisableTailCalls = Args.hasArg(OPT_mdisable_tail_calls);
  541. Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
  542. Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable) ||
  543. Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
  544. Args.hasArg(OPT_cl_fast_relaxed_math);
  545. Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
  546. Opts.NoInfsFPMath = (Args.hasArg(OPT_menable_no_infinities) ||
  547. Args.hasArg(OPT_cl_finite_math_only) ||
  548. Args.hasArg(OPT_cl_fast_relaxed_math));
  549. Opts.NoNaNsFPMath = (Args.hasArg(OPT_menable_no_nans) ||
  550. Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
  551. Args.hasArg(OPT_cl_finite_math_only) ||
  552. Args.hasArg(OPT_cl_fast_relaxed_math));
  553. Opts.NoSignedZeros = (Args.hasArg(OPT_fno_signed_zeros) ||
  554. Args.hasArg(OPT_cl_no_signed_zeros) ||
  555. Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
  556. Args.hasArg(OPT_cl_fast_relaxed_math));
  557. Opts.FlushDenorm = Args.hasArg(OPT_cl_denorms_are_zero);
  558. Opts.CorrectlyRoundedDivSqrt =
  559. Args.hasArg(OPT_cl_fp32_correctly_rounded_divide_sqrt);
  560. Opts.ReciprocalMath = Args.hasArg(OPT_freciprocal_math);
  561. Opts.NoTrappingMath = Args.hasArg(OPT_fno_trapping_math);
  562. Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
  563. Opts.BackendOptions = Args.getAllArgValues(OPT_backend_option);
  564. Opts.NumRegisterParameters = getLastArgIntValue(Args, OPT_mregparm, 0, Diags);
  565. Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
  566. Opts.FatalWarnings = Args.hasArg(OPT_massembler_fatal_warnings);
  567. Opts.EnableSegmentedStacks = Args.hasArg(OPT_split_stacks);
  568. Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
  569. Opts.IncrementalLinkerCompatible =
  570. Args.hasArg(OPT_mincremental_linker_compatible);
  571. Opts.PIECopyRelocations =
  572. Args.hasArg(OPT_mpie_copy_relocations);
  573. Opts.OmitLeafFramePointer = Args.hasArg(OPT_momit_leaf_frame_pointer);
  574. Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
  575. Opts.NoDwarfDirectoryAsm = Args.hasArg(OPT_fno_dwarf_directory_asm);
  576. Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
  577. Opts.StrictEnums = Args.hasArg(OPT_fstrict_enums);
  578. Opts.StrictReturn = !Args.hasArg(OPT_fno_strict_return);
  579. Opts.StrictVTablePointers = Args.hasArg(OPT_fstrict_vtable_pointers);
  580. Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
  581. Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
  582. Args.hasArg(OPT_cl_fast_relaxed_math);
  583. Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
  584. Opts.RelocationModel = getRelocModel(Args, Diags);
  585. Opts.ThreadModel = Args.getLastArgValue(OPT_mthread_model, "posix");
  586. if (Opts.ThreadModel != "posix" && Opts.ThreadModel != "single")
  587. Diags.Report(diag::err_drv_invalid_value)
  588. << Args.getLastArg(OPT_mthread_model)->getAsString(Args)
  589. << Opts.ThreadModel;
  590. Opts.TrapFuncName = Args.getLastArgValue(OPT_ftrap_function_EQ);
  591. Opts.UseInitArray = Args.hasArg(OPT_fuse_init_array);
  592. Opts.FunctionSections = Args.hasFlag(OPT_ffunction_sections,
  593. OPT_fno_function_sections, false);
  594. Opts.DataSections = Args.hasFlag(OPT_fdata_sections,
  595. OPT_fno_data_sections, false);
  596. Opts.UniqueSectionNames = Args.hasFlag(OPT_funique_section_names,
  597. OPT_fno_unique_section_names, true);
  598. Opts.MergeFunctions = Args.hasArg(OPT_fmerge_functions);
  599. Opts.NoUseJumpTables = Args.hasArg(OPT_fno_jump_tables);
  600. Opts.PrepareForLTO = Args.hasArg(OPT_flto, OPT_flto_EQ);
  601. Opts.EmitSummaryIndex = false;
  602. if (Arg *A = Args.getLastArg(OPT_flto_EQ)) {
  603. StringRef S = A->getValue();
  604. if (S == "thin")
  605. Opts.EmitSummaryIndex = true;
  606. else if (S != "full")
  607. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << S;
  608. }
  609. Opts.LTOUnit = Args.hasFlag(OPT_flto_unit, OPT_fno_lto_unit, false);
  610. if (Arg *A = Args.getLastArg(OPT_fthinlto_index_EQ)) {
  611. if (IK.getLanguage() != InputKind::LLVM_IR)
  612. Diags.Report(diag::err_drv_argument_only_allowed_with)
  613. << A->getAsString(Args) << "-x ir";
  614. Opts.ThinLTOIndexFile = Args.getLastArgValue(OPT_fthinlto_index_EQ);
  615. }
  616. Opts.ThinLinkBitcodeFile = Args.getLastArgValue(OPT_fthin_link_bitcode_EQ);
  617. Opts.MSVolatile = Args.hasArg(OPT_fms_volatile);
  618. Opts.VectorizeLoop = Args.hasArg(OPT_vectorize_loops);
  619. Opts.VectorizeSLP = Args.hasArg(OPT_vectorize_slp);
  620. Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
  621. Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
  622. Opts.DisableGCov = Args.hasArg(OPT_test_coverage);
  623. Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
  624. Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
  625. if (Opts.EmitGcovArcs || Opts.EmitGcovNotes) {
  626. Opts.CoverageDataFile = Args.getLastArgValue(OPT_coverage_data_file);
  627. Opts.CoverageNotesFile = Args.getLastArgValue(OPT_coverage_notes_file);
  628. Opts.CoverageExtraChecksum = Args.hasArg(OPT_coverage_cfg_checksum);
  629. Opts.CoverageNoFunctionNamesInData =
  630. Args.hasArg(OPT_coverage_no_function_names_in_data);
  631. Opts.CoverageExitBlockBeforeBody =
  632. Args.hasArg(OPT_coverage_exit_block_before_body);
  633. if (Args.hasArg(OPT_coverage_version_EQ)) {
  634. StringRef CoverageVersion = Args.getLastArgValue(OPT_coverage_version_EQ);
  635. if (CoverageVersion.size() != 4) {
  636. Diags.Report(diag::err_drv_invalid_value)
  637. << Args.getLastArg(OPT_coverage_version_EQ)->getAsString(Args)
  638. << CoverageVersion;
  639. } else {
  640. memcpy(Opts.CoverageVersion, CoverageVersion.data(), 4);
  641. }
  642. }
  643. }
  644. // Handle -fembed-bitcode option.
  645. if (Arg *A = Args.getLastArg(OPT_fembed_bitcode_EQ)) {
  646. StringRef Name = A->getValue();
  647. unsigned Model = llvm::StringSwitch<unsigned>(Name)
  648. .Case("off", CodeGenOptions::Embed_Off)
  649. .Case("all", CodeGenOptions::Embed_All)
  650. .Case("bitcode", CodeGenOptions::Embed_Bitcode)
  651. .Case("marker", CodeGenOptions::Embed_Marker)
  652. .Default(~0U);
  653. if (Model == ~0U) {
  654. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
  655. Success = false;
  656. } else
  657. Opts.setEmbedBitcode(
  658. static_cast<CodeGenOptions::EmbedBitcodeKind>(Model));
  659. }
  660. // FIXME: For backend options that are not yet recorded as function
  661. // attributes in the IR, keep track of them so we can embed them in a
  662. // separate data section and use them when building the bitcode.
  663. if (Opts.getEmbedBitcode() == CodeGenOptions::Embed_All) {
  664. for (const auto &A : Args) {
  665. // Do not encode output and input.
  666. if (A->getOption().getID() == options::OPT_o ||
  667. A->getOption().getID() == options::OPT_INPUT ||
  668. A->getOption().getID() == options::OPT_x ||
  669. A->getOption().getID() == options::OPT_fembed_bitcode ||
  670. (A->getOption().getGroup().isValid() &&
  671. A->getOption().getGroup().getID() == options::OPT_W_Group))
  672. continue;
  673. ArgStringList ASL;
  674. A->render(Args, ASL);
  675. for (const auto &arg : ASL) {
  676. StringRef ArgStr(arg);
  677. Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end());
  678. // using \00 to seperate each commandline options.
  679. Opts.CmdArgs.push_back('\0');
  680. }
  681. }
  682. }
  683. Opts.PreserveVec3Type = Args.hasArg(OPT_fpreserve_vec3_type);
  684. Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
  685. Opts.XRayInstrumentFunctions = Args.hasArg(OPT_fxray_instrument);
  686. Opts.XRayInstructionThreshold =
  687. getLastArgIntValue(Args, OPT_fxray_instruction_threshold_EQ, 200, Diags);
  688. Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
  689. Opts.CallFEntry = Args.hasArg(OPT_mfentry);
  690. Opts.EmitOpenCLArgMetadata = Args.hasArg(OPT_cl_kernel_arg_info);
  691. if (const Arg *A = Args.getLastArg(OPT_compress_debug_sections,
  692. OPT_compress_debug_sections_EQ)) {
  693. if (A->getOption().getID() == OPT_compress_debug_sections) {
  694. // TODO: be more clever about the compression type auto-detection
  695. Opts.setCompressDebugSections(llvm::DebugCompressionType::GNU);
  696. } else {
  697. auto DCT = llvm::StringSwitch<llvm::DebugCompressionType>(A->getValue())
  698. .Case("none", llvm::DebugCompressionType::None)
  699. .Case("zlib", llvm::DebugCompressionType::Z)
  700. .Case("zlib-gnu", llvm::DebugCompressionType::GNU)
  701. .Default(llvm::DebugCompressionType::None);
  702. Opts.setCompressDebugSections(DCT);
  703. }
  704. }
  705. Opts.RelaxELFRelocations = Args.hasArg(OPT_mrelax_relocations);
  706. Opts.DebugCompilationDir = Args.getLastArgValue(OPT_fdebug_compilation_dir);
  707. for (auto A : Args.filtered(OPT_mlink_bitcode_file, OPT_mlink_cuda_bitcode)) {
  708. CodeGenOptions::BitcodeFileToLink F;
  709. F.Filename = A->getValue();
  710. if (A->getOption().matches(OPT_mlink_cuda_bitcode)) {
  711. F.LinkFlags = llvm::Linker::Flags::LinkOnlyNeeded;
  712. // When linking CUDA bitcode, propagate function attributes so that
  713. // e.g. libdevice gets fast-math attrs if we're building with fast-math.
  714. F.PropagateAttrs = true;
  715. F.Internalize = true;
  716. }
  717. Opts.LinkBitcodeFiles.push_back(F);
  718. }
  719. Opts.SanitizeCoverageType =
  720. getLastArgIntValue(Args, OPT_fsanitize_coverage_type, 0, Diags);
  721. Opts.SanitizeCoverageIndirectCalls =
  722. Args.hasArg(OPT_fsanitize_coverage_indirect_calls);
  723. Opts.SanitizeCoverageTraceBB = Args.hasArg(OPT_fsanitize_coverage_trace_bb);
  724. Opts.SanitizeCoverageTraceCmp = Args.hasArg(OPT_fsanitize_coverage_trace_cmp);
  725. Opts.SanitizeCoverageTraceDiv = Args.hasArg(OPT_fsanitize_coverage_trace_div);
  726. Opts.SanitizeCoverageTraceGep = Args.hasArg(OPT_fsanitize_coverage_trace_gep);
  727. Opts.SanitizeCoverage8bitCounters =
  728. Args.hasArg(OPT_fsanitize_coverage_8bit_counters);
  729. Opts.SanitizeCoverageTracePC = Args.hasArg(OPT_fsanitize_coverage_trace_pc);
  730. Opts.SanitizeCoverageTracePCGuard =
  731. Args.hasArg(OPT_fsanitize_coverage_trace_pc_guard);
  732. Opts.SanitizeCoverageNoPrune = Args.hasArg(OPT_fsanitize_coverage_no_prune);
  733. Opts.SanitizeCoverageInline8bitCounters =
  734. Args.hasArg(OPT_fsanitize_coverage_inline_8bit_counters);
  735. Opts.SanitizeMemoryTrackOrigins =
  736. getLastArgIntValue(Args, OPT_fsanitize_memory_track_origins_EQ, 0, Diags);
  737. Opts.SanitizeMemoryUseAfterDtor =
  738. Args.hasArg(OPT_fsanitize_memory_use_after_dtor);
  739. Opts.SanitizeCfiCrossDso = Args.hasArg(OPT_fsanitize_cfi_cross_dso);
  740. Opts.SanitizeStats = Args.hasArg(OPT_fsanitize_stats);
  741. if (Arg *A = Args.getLastArg(OPT_fsanitize_address_use_after_scope,
  742. OPT_fno_sanitize_address_use_after_scope)) {
  743. Opts.SanitizeAddressUseAfterScope =
  744. A->getOption().getID() == OPT_fsanitize_address_use_after_scope;
  745. }
  746. Opts.SanitizeAddressGlobalsDeadStripping =
  747. Args.hasArg(OPT_fsanitize_address_globals_dead_stripping);
  748. Opts.SSPBufferSize =
  749. getLastArgIntValue(Args, OPT_stack_protector_buffer_size, 8, Diags);
  750. Opts.StackRealignment = Args.hasArg(OPT_mstackrealign);
  751. if (Arg *A = Args.getLastArg(OPT_mstack_alignment)) {
  752. StringRef Val = A->getValue();
  753. unsigned StackAlignment = Opts.StackAlignment;
  754. Val.getAsInteger(10, StackAlignment);
  755. Opts.StackAlignment = StackAlignment;
  756. }
  757. if (Arg *A = Args.getLastArg(OPT_mstack_probe_size)) {
  758. StringRef Val = A->getValue();
  759. unsigned StackProbeSize = Opts.StackProbeSize;
  760. Val.getAsInteger(0, StackProbeSize);
  761. Opts.StackProbeSize = StackProbeSize;
  762. }
  763. if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
  764. StringRef Name = A->getValue();
  765. unsigned Method = llvm::StringSwitch<unsigned>(Name)
  766. .Case("legacy", CodeGenOptions::Legacy)
  767. .Case("non-legacy", CodeGenOptions::NonLegacy)
  768. .Case("mixed", CodeGenOptions::Mixed)
  769. .Default(~0U);
  770. if (Method == ~0U) {
  771. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
  772. Success = false;
  773. } else {
  774. Opts.setObjCDispatchMethod(
  775. static_cast<CodeGenOptions::ObjCDispatchMethodKind>(Method));
  776. }
  777. }
  778. Opts.EmulatedTLS =
  779. Args.hasFlag(OPT_femulated_tls, OPT_fno_emulated_tls, false);
  780. if (Arg *A = Args.getLastArg(OPT_ftlsmodel_EQ)) {
  781. StringRef Name = A->getValue();
  782. unsigned Model = llvm::StringSwitch<unsigned>(Name)
  783. .Case("global-dynamic", CodeGenOptions::GeneralDynamicTLSModel)
  784. .Case("local-dynamic", CodeGenOptions::LocalDynamicTLSModel)
  785. .Case("initial-exec", CodeGenOptions::InitialExecTLSModel)
  786. .Case("local-exec", CodeGenOptions::LocalExecTLSModel)
  787. .Default(~0U);
  788. if (Model == ~0U) {
  789. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
  790. Success = false;
  791. } else {
  792. Opts.setDefaultTLSModel(static_cast<CodeGenOptions::TLSModel>(Model));
  793. }
  794. }
  795. if (Arg *A = Args.getLastArg(OPT_fdenormal_fp_math_EQ)) {
  796. StringRef Val = A->getValue();
  797. if (Val == "ieee")
  798. Opts.FPDenormalMode = "ieee";
  799. else if (Val == "preserve-sign")
  800. Opts.FPDenormalMode = "preserve-sign";
  801. else if (Val == "positive-zero")
  802. Opts.FPDenormalMode = "positive-zero";
  803. else
  804. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
  805. }
  806. if (Arg *A = Args.getLastArg(OPT_fpcc_struct_return, OPT_freg_struct_return)) {
  807. if (A->getOption().matches(OPT_fpcc_struct_return)) {
  808. Opts.setStructReturnConvention(CodeGenOptions::SRCK_OnStack);
  809. } else {
  810. assert(A->getOption().matches(OPT_freg_struct_return));
  811. Opts.setStructReturnConvention(CodeGenOptions::SRCK_InRegs);
  812. }
  813. }
  814. Opts.DependentLibraries = Args.getAllArgValues(OPT_dependent_lib);
  815. Opts.LinkerOptions = Args.getAllArgValues(OPT_linker_option);
  816. bool NeedLocTracking = false;
  817. Opts.OptRecordFile = Args.getLastArgValue(OPT_opt_record_file);
  818. if (!Opts.OptRecordFile.empty())
  819. NeedLocTracking = true;
  820. if (Arg *A = Args.getLastArg(OPT_Rpass_EQ)) {
  821. Opts.OptimizationRemarkPattern =
  822. GenerateOptimizationRemarkRegex(Diags, Args, A);
  823. NeedLocTracking = true;
  824. }
  825. if (Arg *A = Args.getLastArg(OPT_Rpass_missed_EQ)) {
  826. Opts.OptimizationRemarkMissedPattern =
  827. GenerateOptimizationRemarkRegex(Diags, Args, A);
  828. NeedLocTracking = true;
  829. }
  830. if (Arg *A = Args.getLastArg(OPT_Rpass_analysis_EQ)) {
  831. Opts.OptimizationRemarkAnalysisPattern =
  832. GenerateOptimizationRemarkRegex(Diags, Args, A);
  833. NeedLocTracking = true;
  834. }
  835. Opts.DiagnosticsWithHotness =
  836. Args.hasArg(options::OPT_fdiagnostics_show_hotness);
  837. bool UsingSampleProfile = !Opts.SampleProfileFile.empty();
  838. bool UsingProfile = UsingSampleProfile ||
  839. (Opts.getProfileUse() != CodeGenOptions::ProfileNone);
  840. if (Opts.DiagnosticsWithHotness && !UsingProfile)
  841. Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
  842. << "-fdiagnostics-show-hotness";
  843. Opts.DiagnosticsHotnessThreshold = getLastArgUInt64Value(
  844. Args, options::OPT_fdiagnostics_hotness_threshold_EQ, 0);
  845. if (Opts.DiagnosticsHotnessThreshold > 0 && !UsingProfile)
  846. Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo)
  847. << "-fdiagnostics-hotness-threshold=";
  848. // If the user requested to use a sample profile for PGO, then the
  849. // backend will need to track source location information so the profile
  850. // can be incorporated into the IR.
  851. if (UsingSampleProfile)
  852. NeedLocTracking = true;
  853. // If the user requested a flag that requires source locations available in
  854. // the backend, make sure that the backend tracks source location information.
  855. if (NeedLocTracking && Opts.getDebugInfo() == codegenoptions::NoDebugInfo)
  856. Opts.setDebugInfo(codegenoptions::LocTrackingOnly);
  857. Opts.RewriteMapFiles = Args.getAllArgValues(OPT_frewrite_map_file);
  858. // Parse -fsanitize-recover= arguments.
  859. // FIXME: Report unrecoverable sanitizers incorrectly specified here.
  860. parseSanitizerKinds("-fsanitize-recover=",
  861. Args.getAllArgValues(OPT_fsanitize_recover_EQ), Diags,
  862. Opts.SanitizeRecover);
  863. parseSanitizerKinds("-fsanitize-trap=",
  864. Args.getAllArgValues(OPT_fsanitize_trap_EQ), Diags,
  865. Opts.SanitizeTrap);
  866. Opts.CudaGpuBinaryFileNames =
  867. Args.getAllArgValues(OPT_fcuda_include_gpubinary);
  868. Opts.Backchain = Args.hasArg(OPT_mbackchain);
  869. Opts.EmitCheckPathComponentsToStrip = getLastArgIntValue(
  870. Args, OPT_fsanitize_undefined_strip_path_components_EQ, 0, Diags);
  871. return Success;
  872. }
  873. static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
  874. ArgList &Args) {
  875. using namespace options;
  876. Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
  877. Opts.Targets = Args.getAllArgValues(OPT_MT);
  878. Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
  879. Opts.IncludeModuleFiles = Args.hasArg(OPT_module_file_deps);
  880. Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
  881. Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
  882. Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
  883. Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
  884. Opts.PrintShowIncludes = Args.hasArg(OPT_show_includes);
  885. Opts.DOTOutputFile = Args.getLastArgValue(OPT_dependency_dot);
  886. Opts.ModuleDependencyOutputDir =
  887. Args.getLastArgValue(OPT_module_dependency_dir);
  888. if (Args.hasArg(OPT_MV))
  889. Opts.OutputFormat = DependencyOutputFormat::NMake;
  890. // Add sanitizer blacklists as extra dependencies.
  891. // They won't be discovered by the regular preprocessor, so
  892. // we let make / ninja to know about this implicit dependency.
  893. Opts.ExtraDeps = Args.getAllArgValues(OPT_fdepfile_entry);
  894. auto ModuleFiles = Args.getAllArgValues(OPT_fmodule_file);
  895. Opts.ExtraDeps.insert(Opts.ExtraDeps.end(), ModuleFiles.begin(),
  896. ModuleFiles.end());
  897. }
  898. static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
  899. // Color diagnostics default to auto ("on" if terminal supports) in the driver
  900. // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
  901. // Support both clang's -f[no-]color-diagnostics and gcc's
  902. // -f[no-]diagnostics-colors[=never|always|auto].
  903. enum {
  904. Colors_On,
  905. Colors_Off,
  906. Colors_Auto
  907. } ShowColors = DefaultColor ? Colors_Auto : Colors_Off;
  908. for (Arg *A : Args) {
  909. const Option &O = A->getOption();
  910. if (O.matches(options::OPT_fcolor_diagnostics) ||
  911. O.matches(options::OPT_fdiagnostics_color)) {
  912. ShowColors = Colors_On;
  913. } else if (O.matches(options::OPT_fno_color_diagnostics) ||
  914. O.matches(options::OPT_fno_diagnostics_color)) {
  915. ShowColors = Colors_Off;
  916. } else if (O.matches(options::OPT_fdiagnostics_color_EQ)) {
  917. StringRef Value(A->getValue());
  918. if (Value == "always")
  919. ShowColors = Colors_On;
  920. else if (Value == "never")
  921. ShowColors = Colors_Off;
  922. else if (Value == "auto")
  923. ShowColors = Colors_Auto;
  924. }
  925. }
  926. return ShowColors == Colors_On ||
  927. (ShowColors == Colors_Auto &&
  928. llvm::sys::Process::StandardErrHasColors());
  929. }
  930. bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
  931. DiagnosticsEngine *Diags,
  932. bool DefaultDiagColor, bool DefaultShowOpt) {
  933. using namespace options;
  934. bool Success = true;
  935. Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
  936. if (Arg *A =
  937. Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
  938. Opts.DiagnosticSerializationFile = A->getValue();
  939. Opts.IgnoreWarnings = Args.hasArg(OPT_w);
  940. Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
  941. Opts.Pedantic = Args.hasArg(OPT_pedantic);
  942. Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
  943. Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
  944. Opts.ShowColors = parseShowColorsArgs(Args, DefaultDiagColor);
  945. Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
  946. OPT_fno_show_column,
  947. /*Default=*/true);
  948. Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
  949. Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
  950. Opts.AbsolutePath = Args.hasArg(OPT_fdiagnostics_absolute_paths);
  951. Opts.ShowOptionNames =
  952. Args.hasFlag(OPT_fdiagnostics_show_option,
  953. OPT_fno_diagnostics_show_option, DefaultShowOpt);
  954. llvm::sys::Process::UseANSIEscapeCodes(Args.hasArg(OPT_fansi_escape_codes));
  955. // Default behavior is to not to show note include stacks.
  956. Opts.ShowNoteIncludeStack = false;
  957. if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
  958. OPT_fno_diagnostics_show_note_include_stack))
  959. if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
  960. Opts.ShowNoteIncludeStack = true;
  961. StringRef ShowOverloads =
  962. Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
  963. if (ShowOverloads == "best")
  964. Opts.setShowOverloads(Ovl_Best);
  965. else if (ShowOverloads == "all")
  966. Opts.setShowOverloads(Ovl_All);
  967. else {
  968. Success = false;
  969. if (Diags)
  970. Diags->Report(diag::err_drv_invalid_value)
  971. << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
  972. << ShowOverloads;
  973. }
  974. StringRef ShowCategory =
  975. Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
  976. if (ShowCategory == "none")
  977. Opts.ShowCategories = 0;
  978. else if (ShowCategory == "id")
  979. Opts.ShowCategories = 1;
  980. else if (ShowCategory == "name")
  981. Opts.ShowCategories = 2;
  982. else {
  983. Success = false;
  984. if (Diags)
  985. Diags->Report(diag::err_drv_invalid_value)
  986. << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
  987. << ShowCategory;
  988. }
  989. StringRef Format =
  990. Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
  991. if (Format == "clang")
  992. Opts.setFormat(DiagnosticOptions::Clang);
  993. else if (Format == "msvc")
  994. Opts.setFormat(DiagnosticOptions::MSVC);
  995. else if (Format == "msvc-fallback") {
  996. Opts.setFormat(DiagnosticOptions::MSVC);
  997. Opts.CLFallbackMode = true;
  998. } else if (Format == "vi")
  999. Opts.setFormat(DiagnosticOptions::Vi);
  1000. else {
  1001. Success = false;
  1002. if (Diags)
  1003. Diags->Report(diag::err_drv_invalid_value)
  1004. << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
  1005. << Format;
  1006. }
  1007. Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
  1008. Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
  1009. Opts.ShowPresumedLoc = !Args.hasArg(OPT_fno_diagnostics_use_presumed_location);
  1010. Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
  1011. DiagnosticLevelMask DiagMask = DiagnosticLevelMask::None;
  1012. Success &= parseDiagnosticLevelMask("-verify-ignore-unexpected=",
  1013. Args.getAllArgValues(OPT_verify_ignore_unexpected_EQ),
  1014. Diags, DiagMask);
  1015. if (Args.hasArg(OPT_verify_ignore_unexpected))
  1016. DiagMask = DiagnosticLevelMask::All;
  1017. Opts.setVerifyIgnoreUnexpected(DiagMask);
  1018. Opts.ElideType = !Args.hasArg(OPT_fno_elide_type);
  1019. Opts.ShowTemplateTree = Args.hasArg(OPT_fdiagnostics_show_template_tree);
  1020. Opts.ErrorLimit = getLastArgIntValue(Args, OPT_ferror_limit, 0, Diags);
  1021. Opts.MacroBacktraceLimit =
  1022. getLastArgIntValue(Args, OPT_fmacro_backtrace_limit,
  1023. DiagnosticOptions::DefaultMacroBacktraceLimit, Diags);
  1024. Opts.TemplateBacktraceLimit = getLastArgIntValue(
  1025. Args, OPT_ftemplate_backtrace_limit,
  1026. DiagnosticOptions::DefaultTemplateBacktraceLimit, Diags);
  1027. Opts.ConstexprBacktraceLimit = getLastArgIntValue(
  1028. Args, OPT_fconstexpr_backtrace_limit,
  1029. DiagnosticOptions::DefaultConstexprBacktraceLimit, Diags);
  1030. Opts.SpellCheckingLimit = getLastArgIntValue(
  1031. Args, OPT_fspell_checking_limit,
  1032. DiagnosticOptions::DefaultSpellCheckingLimit, Diags);
  1033. Opts.SnippetLineLimit = getLastArgIntValue(
  1034. Args, OPT_fcaret_diagnostics_max_lines,
  1035. DiagnosticOptions::DefaultSnippetLineLimit, Diags);
  1036. Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop,
  1037. DiagnosticOptions::DefaultTabStop, Diags);
  1038. if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
  1039. Opts.TabStop = DiagnosticOptions::DefaultTabStop;
  1040. if (Diags)
  1041. Diags->Report(diag::warn_ignoring_ftabstop_value)
  1042. << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
  1043. }
  1044. Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags);
  1045. addDiagnosticArgs(Args, OPT_W_Group, OPT_W_value_Group, Opts.Warnings);
  1046. addDiagnosticArgs(Args, OPT_R_Group, OPT_R_value_Group, Opts.Remarks);
  1047. return Success;
  1048. }
  1049. static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
  1050. Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
  1051. }
  1052. /// Parse the argument to the -ftest-module-file-extension
  1053. /// command-line argument.
  1054. ///
  1055. /// \returns true on error, false on success.
  1056. static bool parseTestModuleFileExtensionArg(StringRef Arg,
  1057. std::string &BlockName,
  1058. unsigned &MajorVersion,
  1059. unsigned &MinorVersion,
  1060. bool &Hashed,
  1061. std::string &UserInfo) {
  1062. SmallVector<StringRef, 5> Args;
  1063. Arg.split(Args, ':', 5);
  1064. if (Args.size() < 5)
  1065. return true;
  1066. BlockName = Args[0];
  1067. if (Args[1].getAsInteger(10, MajorVersion)) return true;
  1068. if (Args[2].getAsInteger(10, MinorVersion)) return true;
  1069. if (Args[3].getAsInteger(2, Hashed)) return true;
  1070. if (Args.size() > 4)
  1071. UserInfo = Args[4];
  1072. return false;
  1073. }
  1074. static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
  1075. DiagnosticsEngine &Diags,
  1076. bool &IsHeaderFile) {
  1077. using namespace options;
  1078. Opts.ProgramAction = frontend::ParseSyntaxOnly;
  1079. if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
  1080. switch (A->getOption().getID()) {
  1081. default:
  1082. llvm_unreachable("Invalid option in group!");
  1083. case OPT_ast_list:
  1084. Opts.ProgramAction = frontend::ASTDeclList; break;
  1085. case OPT_ast_dump:
  1086. case OPT_ast_dump_all:
  1087. case OPT_ast_dump_lookups:
  1088. Opts.ProgramAction = frontend::ASTDump; break;
  1089. case OPT_ast_print:
  1090. Opts.ProgramAction = frontend::ASTPrint; break;
  1091. case OPT_ast_view:
  1092. Opts.ProgramAction = frontend::ASTView; break;
  1093. case OPT_dump_raw_tokens:
  1094. Opts.ProgramAction = frontend::DumpRawTokens; break;
  1095. case OPT_dump_tokens:
  1096. Opts.ProgramAction = frontend::DumpTokens; break;
  1097. case OPT_S:
  1098. Opts.ProgramAction = frontend::EmitAssembly; break;
  1099. case OPT_emit_llvm_bc:
  1100. Opts.ProgramAction = frontend::EmitBC; break;
  1101. case OPT_emit_html:
  1102. Opts.ProgramAction = frontend::EmitHTML; break;
  1103. case OPT_emit_llvm:
  1104. Opts.ProgramAction = frontend::EmitLLVM; break;
  1105. case OPT_emit_llvm_only:
  1106. Opts.ProgramAction = frontend::EmitLLVMOnly; break;
  1107. case OPT_emit_codegen_only:
  1108. Opts.ProgramAction = frontend::EmitCodeGenOnly; break;
  1109. case OPT_emit_obj:
  1110. Opts.ProgramAction = frontend::EmitObj; break;
  1111. case OPT_fixit_EQ:
  1112. Opts.FixItSuffix = A->getValue();
  1113. // fall-through!
  1114. case OPT_fixit:
  1115. Opts.ProgramAction = frontend::FixIt; break;
  1116. case OPT_emit_module:
  1117. Opts.ProgramAction = frontend::GenerateModule; break;
  1118. case OPT_emit_module_interface:
  1119. Opts.ProgramAction = frontend::GenerateModuleInterface; break;
  1120. case OPT_emit_pch:
  1121. Opts.ProgramAction = frontend::GeneratePCH; break;
  1122. case OPT_emit_pth:
  1123. Opts.ProgramAction = frontend::GeneratePTH; break;
  1124. case OPT_init_only:
  1125. Opts.ProgramAction = frontend::InitOnly; break;
  1126. case OPT_fsyntax_only:
  1127. Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
  1128. case OPT_module_file_info:
  1129. Opts.ProgramAction = frontend::ModuleFileInfo; break;
  1130. case OPT_verify_pch:
  1131. Opts.ProgramAction = frontend::VerifyPCH; break;
  1132. case OPT_print_decl_contexts:
  1133. Opts.ProgramAction = frontend::PrintDeclContext; break;
  1134. case OPT_print_preamble:
  1135. Opts.ProgramAction = frontend::PrintPreamble; break;
  1136. case OPT_E:
  1137. Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
  1138. case OPT_rewrite_macros:
  1139. Opts.ProgramAction = frontend::RewriteMacros; break;
  1140. case OPT_rewrite_objc:
  1141. Opts.ProgramAction = frontend::RewriteObjC; break;
  1142. case OPT_rewrite_test:
  1143. Opts.ProgramAction = frontend::RewriteTest; break;
  1144. case OPT_analyze:
  1145. Opts.ProgramAction = frontend::RunAnalysis; break;
  1146. case OPT_migrate:
  1147. Opts.ProgramAction = frontend::MigrateSource; break;
  1148. case OPT_Eonly:
  1149. Opts.ProgramAction = frontend::RunPreprocessorOnly; break;
  1150. }
  1151. }
  1152. if (const Arg* A = Args.getLastArg(OPT_plugin)) {
  1153. Opts.Plugins.emplace_back(A->getValue(0));
  1154. Opts.ProgramAction = frontend::PluginAction;
  1155. Opts.ActionName = A->getValue();
  1156. }
  1157. Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
  1158. for (const Arg *AA : Args.filtered(OPT_plugin_arg))
  1159. Opts.PluginArgs[AA->getValue(0)].emplace_back(AA->getValue(1));
  1160. for (const std::string &Arg :
  1161. Args.getAllArgValues(OPT_ftest_module_file_extension_EQ)) {
  1162. std::string BlockName;
  1163. unsigned MajorVersion;
  1164. unsigned MinorVersion;
  1165. bool Hashed;
  1166. std::string UserInfo;
  1167. if (parseTestModuleFileExtensionArg(Arg, BlockName, MajorVersion,
  1168. MinorVersion, Hashed, UserInfo)) {
  1169. Diags.Report(diag::err_test_module_file_extension_format) << Arg;
  1170. continue;
  1171. }
  1172. // Add the testing module file extension.
  1173. Opts.ModuleFileExtensions.push_back(
  1174. std::make_shared<TestModuleFileExtension>(
  1175. BlockName, MajorVersion, MinorVersion, Hashed, UserInfo));
  1176. }
  1177. if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
  1178. Opts.CodeCompletionAt =
  1179. ParsedSourceLocation::FromString(A->getValue());
  1180. if (Opts.CodeCompletionAt.FileName.empty())
  1181. Diags.Report(diag::err_drv_invalid_value)
  1182. << A->getAsString(Args) << A->getValue();
  1183. }
  1184. Opts.DisableFree = Args.hasArg(OPT_disable_free);
  1185. Opts.OutputFile = Args.getLastArgValue(OPT_o);
  1186. Opts.Plugins = Args.getAllArgValues(OPT_load);
  1187. Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
  1188. Opts.ShowHelp = Args.hasArg(OPT_help);
  1189. Opts.ShowStats = Args.hasArg(OPT_print_stats);
  1190. Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
  1191. Opts.ShowVersion = Args.hasArg(OPT_version);
  1192. Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
  1193. Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
  1194. Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
  1195. Opts.FixOnlyWarnings = Args.hasArg(OPT_fix_only_warnings);
  1196. Opts.FixAndRecompile = Args.hasArg(OPT_fixit_recompile);
  1197. Opts.FixToTemporaries = Args.hasArg(OPT_fixit_to_temp);
  1198. Opts.ASTDumpDecls = Args.hasArg(OPT_ast_dump);
  1199. Opts.ASTDumpAll = Args.hasArg(OPT_ast_dump_all);
  1200. Opts.ASTDumpFilter = Args.getLastArgValue(OPT_ast_dump_filter);
  1201. Opts.ASTDumpLookups = Args.hasArg(OPT_ast_dump_lookups);
  1202. Opts.UseGlobalModuleIndex = !Args.hasArg(OPT_fno_modules_global_index);
  1203. Opts.GenerateGlobalModuleIndex = Opts.UseGlobalModuleIndex;
  1204. Opts.ModuleMapFiles = Args.getAllArgValues(OPT_fmodule_map_file);
  1205. Opts.ModuleFiles = Args.getAllArgValues(OPT_fmodule_file);
  1206. Opts.ModulesEmbedFiles = Args.getAllArgValues(OPT_fmodules_embed_file_EQ);
  1207. Opts.ModulesEmbedAllFiles = Args.hasArg(OPT_fmodules_embed_all_files);
  1208. Opts.IncludeTimestamps = !Args.hasArg(OPT_fno_pch_timestamp);
  1209. Opts.CodeCompleteOpts.IncludeMacros
  1210. = Args.hasArg(OPT_code_completion_macros);
  1211. Opts.CodeCompleteOpts.IncludeCodePatterns
  1212. = Args.hasArg(OPT_code_completion_patterns);
  1213. Opts.CodeCompleteOpts.IncludeGlobals
  1214. = !Args.hasArg(OPT_no_code_completion_globals);
  1215. Opts.CodeCompleteOpts.IncludeBriefComments
  1216. = Args.hasArg(OPT_code_completion_brief_comments);
  1217. Opts.OverrideRecordLayoutsFile
  1218. = Args.getLastArgValue(OPT_foverride_record_layout_EQ);
  1219. Opts.AuxTriple =
  1220. llvm::Triple::normalize(Args.getLastArgValue(OPT_aux_triple));
  1221. Opts.FindPchSource = Args.getLastArgValue(OPT_find_pch_source_EQ);
  1222. Opts.StatsFile = Args.getLastArgValue(OPT_stats_file);
  1223. if (const Arg *A = Args.getLastArg(OPT_arcmt_check,
  1224. OPT_arcmt_modify,
  1225. OPT_arcmt_migrate)) {
  1226. switch (A->getOption().getID()) {
  1227. default:
  1228. llvm_unreachable("missed a case");
  1229. case OPT_arcmt_check:
  1230. Opts.ARCMTAction = FrontendOptions::ARCMT_Check;
  1231. break;
  1232. case OPT_arcmt_modify:
  1233. Opts.ARCMTAction = FrontendOptions::ARCMT_Modify;
  1234. break;
  1235. case OPT_arcmt_migrate:
  1236. Opts.ARCMTAction = FrontendOptions::ARCMT_Migrate;
  1237. break;
  1238. }
  1239. }
  1240. Opts.MTMigrateDir = Args.getLastArgValue(OPT_mt_migrate_directory);
  1241. Opts.ARCMTMigrateReportOut
  1242. = Args.getLastArgValue(OPT_arcmt_migrate_report_output);
  1243. Opts.ARCMTMigrateEmitARCErrors
  1244. = Args.hasArg(OPT_arcmt_migrate_emit_arc_errors);
  1245. if (Args.hasArg(OPT_objcmt_migrate_literals))
  1246. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Literals;
  1247. if (Args.hasArg(OPT_objcmt_migrate_subscripting))
  1248. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Subscripting;
  1249. if (Args.hasArg(OPT_objcmt_migrate_property_dot_syntax))
  1250. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_PropertyDotSyntax;
  1251. if (Args.hasArg(OPT_objcmt_migrate_property))
  1252. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Property;
  1253. if (Args.hasArg(OPT_objcmt_migrate_readonly_property))
  1254. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ReadonlyProperty;
  1255. if (Args.hasArg(OPT_objcmt_migrate_readwrite_property))
  1256. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ReadwriteProperty;
  1257. if (Args.hasArg(OPT_objcmt_migrate_annotation))
  1258. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Annotation;
  1259. if (Args.hasArg(OPT_objcmt_returns_innerpointer_property))
  1260. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ReturnsInnerPointerProperty;
  1261. if (Args.hasArg(OPT_objcmt_migrate_instancetype))
  1262. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_Instancetype;
  1263. if (Args.hasArg(OPT_objcmt_migrate_nsmacros))
  1264. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_NsMacros;
  1265. if (Args.hasArg(OPT_objcmt_migrate_protocol_conformance))
  1266. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_ProtocolConformance;
  1267. if (Args.hasArg(OPT_objcmt_atomic_property))
  1268. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_AtomicProperty;
  1269. if (Args.hasArg(OPT_objcmt_ns_nonatomic_iosonly))
  1270. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_NsAtomicIOSOnlyProperty;
  1271. if (Args.hasArg(OPT_objcmt_migrate_designated_init))
  1272. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_DesignatedInitializer;
  1273. if (Args.hasArg(OPT_objcmt_migrate_all))
  1274. Opts.ObjCMTAction |= FrontendOptions::ObjCMT_MigrateDecls;
  1275. Opts.ObjCMTWhiteListPath = Args.getLastArgValue(OPT_objcmt_whitelist_dir_path);
  1276. if (Opts.ARCMTAction != FrontendOptions::ARCMT_None &&
  1277. Opts.ObjCMTAction != FrontendOptions::ObjCMT_None) {
  1278. Diags.Report(diag::err_drv_argument_not_allowed_with)
  1279. << "ARC migration" << "ObjC migration";
  1280. }
  1281. InputKind DashX(InputKind::Unknown);
  1282. if (const Arg *A = Args.getLastArg(OPT_x)) {
  1283. StringRef XValue = A->getValue();
  1284. // Parse suffixes: '<lang>(-header|[-module-map][-cpp-output])'.
  1285. // FIXME: Supporting '<lang>-header-cpp-output' would be useful.
  1286. bool Preprocessed = XValue.consume_back("-cpp-output");
  1287. bool ModuleMap = XValue.consume_back("-module-map");
  1288. IsHeaderFile =
  1289. !Preprocessed && !ModuleMap && XValue.consume_back("-header");
  1290. // Principal languages.
  1291. DashX = llvm::StringSwitch<InputKind>(XValue)
  1292. .Case("c", InputKind::C)
  1293. .Case("cl", InputKind::OpenCL)
  1294. .Case("cuda", InputKind::CUDA)
  1295. .Case("c++", InputKind::CXX)
  1296. .Case("objective-c", InputKind::ObjC)
  1297. .Case("objective-c++", InputKind::ObjCXX)
  1298. .Case("renderscript", InputKind::RenderScript)
  1299. .Default(InputKind::Unknown);
  1300. // "objc[++]-cpp-output" is an acceptable synonym for
  1301. // "objective-c[++]-cpp-output".
  1302. if (DashX.isUnknown() && Preprocessed && !IsHeaderFile && !ModuleMap)
  1303. DashX = llvm::StringSwitch<InputKind>(XValue)
  1304. .Case("objc", InputKind::ObjC)
  1305. .Case("objc++", InputKind::ObjCXX)
  1306. .Default(InputKind::Unknown);
  1307. // Some special cases cannot be combined with suffixes.
  1308. if (DashX.isUnknown() && !Preprocessed && !ModuleMap && !IsHeaderFile)
  1309. DashX = llvm::StringSwitch<InputKind>(XValue)
  1310. .Case("cpp-output", InputKind(InputKind::C).getPreprocessed())
  1311. .Case("assembler-with-cpp", InputKind::Asm)
  1312. .Cases("ast", "pcm",
  1313. InputKind(InputKind::Unknown, InputKind::Precompiled))
  1314. .Case("ir", InputKind::LLVM_IR)
  1315. .Default(InputKind::Unknown);
  1316. if (DashX.isUnknown())
  1317. Diags.Report(diag::err_drv_invalid_value)
  1318. << A->getAsString(Args) << A->getValue();
  1319. if (Preprocessed)
  1320. DashX = DashX.getPreprocessed();
  1321. if (ModuleMap)
  1322. DashX = DashX.withFormat(InputKind::ModuleMap);
  1323. }
  1324. // '-' is the default input if none is given.
  1325. std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
  1326. Opts.Inputs.clear();
  1327. if (Inputs.empty())
  1328. Inputs.push_back("-");
  1329. for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
  1330. InputKind IK = DashX;
  1331. if (IK.isUnknown()) {
  1332. IK = FrontendOptions::getInputKindForExtension(
  1333. StringRef(Inputs[i]).rsplit('.').second);
  1334. // FIXME: Warn on this?
  1335. if (IK.isUnknown())
  1336. IK = InputKind::C;
  1337. // FIXME: Remove this hack.
  1338. if (i == 0)
  1339. DashX = IK;
  1340. }
  1341. // The -emit-module action implicitly takes a module map.
  1342. if (Opts.ProgramAction == frontend::GenerateModule &&
  1343. IK.getFormat() == InputKind::Source)
  1344. IK = IK.withFormat(InputKind::ModuleMap);
  1345. Opts.Inputs.emplace_back(std::move(Inputs[i]), IK);
  1346. }
  1347. return DashX;
  1348. }
  1349. std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
  1350. void *MainAddr) {
  1351. std::string ClangExecutable =
  1352. llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
  1353. StringRef Dir = llvm::sys::path::parent_path(ClangExecutable);
  1354. // Compute the path to the resource directory.
  1355. StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
  1356. SmallString<128> P(Dir);
  1357. if (ClangResourceDir != "")
  1358. llvm::sys::path::append(P, ClangResourceDir);
  1359. else
  1360. llvm::sys::path::append(P, "..", Twine("lib") + CLANG_LIBDIR_SUFFIX,
  1361. "clang", CLANG_VERSION_STRING);
  1362. return P.str();
  1363. }
  1364. static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args,
  1365. const std::string &WorkingDir) {
  1366. using namespace options;
  1367. Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
  1368. Opts.Verbose = Args.hasArg(OPT_v);
  1369. Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
  1370. Opts.UseStandardSystemIncludes = !Args.hasArg(OPT_nostdsysteminc);
  1371. Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
  1372. if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
  1373. Opts.UseLibcxx = (strcmp(A->getValue(), "libc++") == 0);
  1374. Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
  1375. // Canonicalize -fmodules-cache-path before storing it.
  1376. SmallString<128> P(Args.getLastArgValue(OPT_fmodules_cache_path));
  1377. if (!(P.empty() || llvm::sys::path::is_absolute(P))) {
  1378. if (WorkingDir.empty())
  1379. llvm::sys::fs::make_absolute(P);
  1380. else
  1381. llvm::sys::fs::make_absolute(WorkingDir, P);
  1382. }
  1383. llvm::sys::path::remove_dots(P);
  1384. Opts.ModuleCachePath = P.str();
  1385. Opts.ModuleUserBuildPath = Args.getLastArgValue(OPT_fmodules_user_build_path);
  1386. for (const Arg *A : Args.filtered(OPT_fprebuilt_module_path))
  1387. Opts.AddPrebuiltModulePath(A->getValue());
  1388. Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
  1389. Opts.ModulesHashContent = Args.hasArg(OPT_fmodules_hash_content);
  1390. Opts.ModulesValidateDiagnosticOptions =
  1391. !Args.hasArg(OPT_fmodules_disable_diagnostic_validation);
  1392. Opts.ImplicitModuleMaps = Args.hasArg(OPT_fimplicit_module_maps);
  1393. Opts.ModuleMapFileHomeIsCwd = Args.hasArg(OPT_fmodule_map_file_home_is_cwd);
  1394. Opts.ModuleCachePruneInterval =
  1395. getLastArgIntValue(Args, OPT_fmodules_prune_interval, 7 * 24 * 60 * 60);
  1396. Opts.ModuleCachePruneAfter =
  1397. getLastArgIntValue(Args, OPT_fmodules_prune_after, 31 * 24 * 60 * 60);
  1398. Opts.ModulesValidateOncePerBuildSession =
  1399. Args.hasArg(OPT_fmodules_validate_once_per_build_session);
  1400. Opts.BuildSessionTimestamp =
  1401. getLastArgUInt64Value(Args, OPT_fbuild_session_timestamp, 0);
  1402. Opts.ModulesValidateSystemHeaders =
  1403. Args.hasArg(OPT_fmodules_validate_system_headers);
  1404. if (const Arg *A = Args.getLastArg(OPT_fmodule_format_EQ))
  1405. Opts.ModuleFormat = A->getValue();
  1406. for (const Arg *A : Args.filtered(OPT_fmodules_ignore_macro)) {
  1407. StringRef MacroDef = A->getValue();
  1408. Opts.ModulesIgnoreMacros.insert(
  1409. llvm::CachedHashString(MacroDef.split('=').first));
  1410. }
  1411. // Add -I..., -F..., and -index-header-map options in order.
  1412. bool IsIndexHeaderMap = false;
  1413. bool IsSysrootSpecified =
  1414. Args.hasArg(OPT__sysroot_EQ) || Args.hasArg(OPT_isysroot);
  1415. for (const Arg *A : Args.filtered(OPT_I, OPT_F, OPT_index_header_map)) {
  1416. if (A->getOption().matches(OPT_index_header_map)) {
  1417. // -index-header-map applies to the next -I or -F.
  1418. IsIndexHeaderMap = true;
  1419. continue;
  1420. }
  1421. frontend::IncludeDirGroup Group =
  1422. IsIndexHeaderMap ? frontend::IndexHeaderMap : frontend::Angled;
  1423. bool IsFramework = A->getOption().matches(OPT_F);
  1424. std::string Path = A->getValue();
  1425. if (IsSysrootSpecified && !IsFramework && A->getValue()[0] == '=') {
  1426. SmallString<32> Buffer;
  1427. llvm::sys::path::append(Buffer, Opts.Sysroot,
  1428. llvm::StringRef(A->getValue()).substr(1));
  1429. Path = Buffer.str();
  1430. }
  1431. Opts.AddPath(Path, Group, IsFramework,
  1432. /*IgnoreSysroot*/ true);
  1433. IsIndexHeaderMap = false;
  1434. }
  1435. // Add -iprefix/-iwithprefix/-iwithprefixbefore options.
  1436. StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
  1437. for (const Arg *A :
  1438. Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
  1439. if (A->getOption().matches(OPT_iprefix))
  1440. Prefix = A->getValue();
  1441. else if (A->getOption().matches(OPT_iwithprefix))
  1442. Opts.AddPath(Prefix.str() + A->getValue(), frontend::After, false, true);
  1443. else
  1444. Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true);
  1445. }
  1446. for (const Arg *A : Args.filtered(OPT_idirafter))
  1447. Opts.AddPath(A->getValue(), frontend::After, false, true);
  1448. for (const Arg *A : Args.filtered(OPT_iquote))
  1449. Opts.AddPath(A->getValue(), frontend::Quoted, false, true);
  1450. for (const Arg *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
  1451. Opts.AddPath(A->getValue(), frontend::System, false,
  1452. !A->getOption().matches(OPT_iwithsysroot));
  1453. for (const Arg *A : Args.filtered(OPT_iframework))
  1454. Opts.AddPath(A->getValue(), frontend::System, true, true);
  1455. for (const Arg *A : Args.filtered(OPT_iframeworkwithsysroot))
  1456. Opts.AddPath(A->getValue(), frontend::System, /*IsFramework=*/true,
  1457. /*IgnoreSysRoot=*/false);
  1458. // Add the paths for the various language specific isystem flags.
  1459. for (const Arg *A : Args.filtered(OPT_c_isystem))
  1460. Opts.AddPath(A->getValue(), frontend::CSystem, false, true);
  1461. for (const Arg *A : Args.filtered(OPT_cxx_isystem))
  1462. Opts.AddPath(A->getValue(), frontend::CXXSystem, false, true);
  1463. for (const Arg *A : Args.filtered(OPT_objc_isystem))
  1464. Opts.AddPath(A->getValue(), frontend::ObjCSystem, false,true);
  1465. for (const Arg *A : Args.filtered(OPT_objcxx_isystem))
  1466. Opts.AddPath(A->getValue(), frontend::ObjCXXSystem, false, true);
  1467. // Add the internal paths from a driver that detects standard include paths.
  1468. for (const Arg *A :
  1469. Args.filtered(OPT_internal_isystem, OPT_internal_externc_isystem)) {
  1470. frontend::IncludeDirGroup Group = frontend::System;
  1471. if (A->getOption().matches(OPT_internal_externc_isystem))
  1472. Group = frontend::ExternCSystem;
  1473. Opts.AddPath(A->getValue(), Group, false, true);
  1474. }
  1475. // Add the path prefixes which are implicitly treated as being system headers.
  1476. for (const Arg *A :
  1477. Args.filtered(OPT_system_header_prefix, OPT_no_system_header_prefix))
  1478. Opts.AddSystemHeaderPrefix(
  1479. A->getValue(), A->getOption().matches(OPT_system_header_prefix));
  1480. for (const Arg *A : Args.filtered(OPT_ivfsoverlay))
  1481. Opts.AddVFSOverlayFile(A->getValue());
  1482. }
  1483. void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
  1484. const llvm::Triple &T,
  1485. PreprocessorOptions &PPOpts,
  1486. LangStandard::Kind LangStd) {
  1487. // Set some properties which depend solely on the input kind; it would be nice
  1488. // to move these to the language standard, and have the driver resolve the
  1489. // input kind + language standard.
  1490. //
  1491. // FIXME: Perhaps a better model would be for a single source file to have
  1492. // multiple language standards (C / C++ std, ObjC std, OpenCL std, OpenMP std)
  1493. // simultaneously active?
  1494. if (IK.getLanguage() == InputKind::Asm) {
  1495. Opts.AsmPreprocessor = 1;
  1496. } else if (IK.isObjectiveC()) {
  1497. Opts.ObjC1 = Opts.ObjC2 = 1;
  1498. }
  1499. if (LangStd == LangStandard::lang_unspecified) {
  1500. // Based on the base language, pick one.
  1501. switch (IK.getLanguage()) {
  1502. case InputKind::Unknown:
  1503. case InputKind::LLVM_IR:
  1504. llvm_unreachable("Invalid input kind!");
  1505. case InputKind::OpenCL:
  1506. LangStd = LangStandard::lang_opencl10;
  1507. break;
  1508. case InputKind::CUDA:
  1509. LangStd = LangStandard::lang_cuda;
  1510. break;
  1511. case InputKind::Asm:
  1512. case InputKind::C:
  1513. // The PS4 uses C99 as the default C standard.
  1514. if (T.isPS4())
  1515. LangStd = LangStandard::lang_gnu99;
  1516. else
  1517. LangStd = LangStandard::lang_gnu11;
  1518. break;
  1519. case InputKind::ObjC:
  1520. LangStd = LangStandard::lang_gnu11;
  1521. break;
  1522. case InputKind::CXX:
  1523. case InputKind::ObjCXX:
  1524. // The PS4 uses C++11 as the default C++ standard.
  1525. if (T.isPS4())
  1526. LangStd = LangStandard::lang_gnucxx11;
  1527. else
  1528. LangStd = LangStandard::lang_gnucxx98;
  1529. break;
  1530. case InputKind::RenderScript:
  1531. LangStd = LangStandard::lang_c99;
  1532. break;
  1533. }
  1534. }
  1535. const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
  1536. Opts.LineComment = Std.hasLineComments();
  1537. Opts.C99 = Std.isC99();
  1538. Opts.C11 = Std.isC11();
  1539. Opts.CPlusPlus = Std.isCPlusPlus();
  1540. Opts.CPlusPlus11 = Std.isCPlusPlus11();
  1541. Opts.CPlusPlus14 = Std.isCPlusPlus14();
  1542. Opts.CPlusPlus1z = Std.isCPlusPlus1z();
  1543. Opts.Digraphs = Std.hasDigraphs();
  1544. Opts.GNUMode = Std.isGNUMode();
  1545. Opts.GNUInline = !Opts.C99 && !Opts.CPlusPlus;
  1546. Opts.HexFloats = Std.hasHexFloats();
  1547. Opts.ImplicitInt = Std.hasImplicitInt();
  1548. // Set OpenCL Version.
  1549. Opts.OpenCL = Std.isOpenCL();
  1550. if (LangStd == LangStandard::lang_opencl10)
  1551. Opts.OpenCLVersion = 100;
  1552. else if (LangStd == LangStandard::lang_opencl11)
  1553. Opts.OpenCLVersion = 110;
  1554. else if (LangStd == LangStandard::lang_opencl12)
  1555. Opts.OpenCLVersion = 120;
  1556. else if (LangStd == LangStandard::lang_opencl20)
  1557. Opts.OpenCLVersion = 200;
  1558. // OpenCL has some additional defaults.
  1559. if (Opts.OpenCL) {
  1560. Opts.AltiVec = 0;
  1561. Opts.ZVector = 0;
  1562. Opts.LaxVectorConversions = 0;
  1563. Opts.setDefaultFPContractMode(LangOptions::FPC_On);
  1564. Opts.NativeHalfType = 1;
  1565. Opts.NativeHalfArgsAndReturns = 1;
  1566. // Include default header file for OpenCL.
  1567. if (Opts.IncludeDefaultHeader) {
  1568. PPOpts.Includes.push_back("opencl-c.h");
  1569. }
  1570. }
  1571. Opts.CUDA = IK.getLanguage() == InputKind::CUDA;
  1572. if (Opts.CUDA)
  1573. // Set default FP_CONTRACT to FAST.
  1574. Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
  1575. Opts.RenderScript = IK.getLanguage() == InputKind::RenderScript;
  1576. if (Opts.RenderScript) {
  1577. Opts.NativeHalfType = 1;
  1578. Opts.NativeHalfArgsAndReturns = 1;
  1579. }
  1580. // OpenCL and C++ both have bool, true, false keywords.
  1581. Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
  1582. // OpenCL has half keyword
  1583. Opts.Half = Opts.OpenCL;
  1584. // C++ has wchar_t keyword.
  1585. Opts.WChar = Opts.CPlusPlus;
  1586. Opts.GNUKeywords = Opts.GNUMode;
  1587. Opts.CXXOperatorNames = Opts.CPlusPlus;
  1588. Opts.AlignedAllocation = Opts.CPlusPlus1z;
  1589. Opts.DollarIdents = !Opts.AsmPreprocessor;
  1590. }
  1591. /// Attempt to parse a visibility value out of the given argument.
  1592. static Visibility parseVisibility(Arg *arg, ArgList &args,
  1593. DiagnosticsEngine &diags) {
  1594. StringRef value = arg->getValue();
  1595. if (value == "default") {
  1596. return DefaultVisibility;
  1597. } else if (value == "hidden" || value == "internal") {
  1598. return HiddenVisibility;
  1599. } else if (value == "protected") {
  1600. // FIXME: diagnose if target does not support protected visibility
  1601. return ProtectedVisibility;
  1602. }
  1603. diags.Report(diag::err_drv_invalid_value)
  1604. << arg->getAsString(args) << value;
  1605. return DefaultVisibility;
  1606. }
  1607. /// Check if input file kind and language standard are compatible.
  1608. static bool IsInputCompatibleWithStandard(InputKind IK,
  1609. const LangStandard &S) {
  1610. switch (IK.getLanguage()) {
  1611. case InputKind::Unknown:
  1612. case InputKind::LLVM_IR:
  1613. llvm_unreachable("should not parse language flags for this input");
  1614. case InputKind::C:
  1615. case InputKind::ObjC:
  1616. case InputKind::RenderScript:
  1617. return S.getLanguage() == InputKind::C;
  1618. case InputKind::OpenCL:
  1619. return S.getLanguage() == InputKind::OpenCL;
  1620. case InputKind::CXX:
  1621. case InputKind::ObjCXX:
  1622. return S.getLanguage() == InputKind::CXX;
  1623. case InputKind::CUDA:
  1624. // FIXME: What -std= values should be permitted for CUDA compilations?
  1625. return S.getLanguage() == InputKind::CUDA ||
  1626. S.getLanguage() == InputKind::CXX;
  1627. case InputKind::Asm:
  1628. // Accept (and ignore) all -std= values.
  1629. // FIXME: The -std= value is not ignored; it affects the tokenization
  1630. // and preprocessing rules if we're preprocessing this asm input.
  1631. return true;
  1632. }
  1633. llvm_unreachable("unexpected input language");
  1634. }
  1635. /// Get language name for given input kind.
  1636. static const StringRef GetInputKindName(InputKind IK) {
  1637. switch (IK.getLanguage()) {
  1638. case InputKind::C:
  1639. return "C";
  1640. case InputKind::ObjC:
  1641. return "Objective-C";
  1642. case InputKind::CXX:
  1643. return "C++";
  1644. case InputKind::ObjCXX:
  1645. return "Objective-C++";
  1646. case InputKind::OpenCL:
  1647. return "OpenCL";
  1648. case InputKind::CUDA:
  1649. return "CUDA";
  1650. case InputKind::RenderScript:
  1651. return "RenderScript";
  1652. case InputKind::Asm:
  1653. return "Asm";
  1654. case InputKind::LLVM_IR:
  1655. return "LLVM IR";
  1656. case InputKind::Unknown:
  1657. break;
  1658. }
  1659. llvm_unreachable("unknown input language");
  1660. }
  1661. static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
  1662. const TargetOptions &TargetOpts,
  1663. PreprocessorOptions &PPOpts,
  1664. DiagnosticsEngine &Diags) {
  1665. // FIXME: Cleanup per-file based stuff.
  1666. LangStandard::Kind LangStd = LangStandard::lang_unspecified;
  1667. if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
  1668. LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
  1669. #define LANGSTANDARD(id, name, lang, desc, features) \
  1670. .Case(name, LangStandard::lang_##id)
  1671. #define LANGSTANDARD_ALIAS(id, alias) \
  1672. .Case(alias, LangStandard::lang_##id)
  1673. #include "clang/Frontend/LangStandards.def"
  1674. .Default(LangStandard::lang_unspecified);
  1675. if (LangStd == LangStandard::lang_unspecified) {
  1676. Diags.Report(diag::err_drv_invalid_value)
  1677. << A->getAsString(Args) << A->getValue();
  1678. // Report supported standards with short description.
  1679. for (unsigned KindValue = 0;
  1680. KindValue != LangStandard::lang_unspecified;
  1681. ++KindValue) {
  1682. const LangStandard &Std = LangStandard::getLangStandardForKind(
  1683. static_cast<LangStandard::Kind>(KindValue));
  1684. if (IsInputCompatibleWithStandard(IK, Std)) {
  1685. auto Diag = Diags.Report(diag::note_drv_use_standard);
  1686. Diag << Std.getName() << Std.getDescription();
  1687. unsigned NumAliases = 0;
  1688. #define LANGSTANDARD(id, name, lang, desc, features)
  1689. #define LANGSTANDARD_ALIAS(id, alias) \
  1690. if (KindValue == LangStandard::lang_##id) ++NumAliases;
  1691. #define LANGSTANDARD_ALIAS_DEPR(id, alias)
  1692. #include "clang/Frontend/LangStandards.def"
  1693. Diag << NumAliases;
  1694. #define LANGSTANDARD(id, name, lang, desc, features)
  1695. #define LANGSTANDARD_ALIAS(id, alias) \
  1696. if (KindValue == LangStandard::lang_##id) Diag << alias;
  1697. #define LANGSTANDARD_ALIAS_DEPR(id, alias)
  1698. #include "clang/Frontend/LangStandards.def"
  1699. }
  1700. }
  1701. } else {
  1702. // Valid standard, check to make sure language and standard are
  1703. // compatible.
  1704. const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
  1705. if (!IsInputCompatibleWithStandard(IK, Std)) {
  1706. Diags.Report(diag::err_drv_argument_not_allowed_with)
  1707. << A->getAsString(Args) << GetInputKindName(IK);
  1708. }
  1709. }
  1710. }
  1711. // -cl-std only applies for OpenCL language standards.
  1712. // Override the -std option in this case.
  1713. if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
  1714. LangStandard::Kind OpenCLLangStd
  1715. = llvm::StringSwitch<LangStandard::Kind>(A->getValue())
  1716. .Cases("cl", "CL", LangStandard::lang_opencl10)
  1717. .Cases("cl1.1", "CL1.1", LangStandard::lang_opencl11)
  1718. .Cases("cl1.2", "CL1.2", LangStandard::lang_opencl12)
  1719. .Cases("cl2.0", "CL2.0", LangStandard::lang_opencl20)
  1720. .Default(LangStandard::lang_unspecified);
  1721. if (OpenCLLangStd == LangStandard::lang_unspecified) {
  1722. Diags.Report(diag::err_drv_invalid_value)
  1723. << A->getAsString(Args) << A->getValue();
  1724. }
  1725. else
  1726. LangStd = OpenCLLangStd;
  1727. }
  1728. Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
  1729. llvm::Triple T(TargetOpts.Triple);
  1730. CompilerInvocation::setLangDefaults(Opts, IK, T, PPOpts, LangStd);
  1731. // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.
  1732. // This option should be deprecated for CL > 1.0 because
  1733. // this option was added for compatibility with OpenCL 1.0.
  1734. if (Args.getLastArg(OPT_cl_strict_aliasing)
  1735. && Opts.OpenCLVersion > 100) {
  1736. std::string VerSpec = llvm::to_string(Opts.OpenCLVersion / 100) +
  1737. std::string(".") +
  1738. llvm::to_string((Opts.OpenCLVersion % 100) / 10);
  1739. Diags.Report(diag::warn_option_invalid_ocl_version)
  1740. << VerSpec << Args.getLastArg(OPT_cl_strict_aliasing)->getAsString(Args);
  1741. }
  1742. // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
  1743. // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
  1744. // while a subset (the non-C++ GNU keywords) is provided by GCC's
  1745. // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
  1746. // name, as it doesn't seem a useful distinction.
  1747. Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
  1748. Opts.GNUKeywords);
  1749. if (Args.hasArg(OPT_fno_operator_names))
  1750. Opts.CXXOperatorNames = 0;
  1751. if (Args.hasArg(OPT_fcuda_is_device))
  1752. Opts.CUDAIsDevice = 1;
  1753. if (Args.hasArg(OPT_fcuda_allow_variadic_functions))
  1754. Opts.CUDAAllowVariadicFunctions = 1;
  1755. if (Args.hasArg(OPT_fno_cuda_host_device_constexpr))
  1756. Opts.CUDAHostDeviceConstexpr = 0;
  1757. if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_flush_denormals_to_zero))
  1758. Opts.CUDADeviceFlushDenormalsToZero = 1;
  1759. if (Opts.CUDAIsDevice && Args.hasArg(OPT_fcuda_approx_transcendentals))
  1760. Opts.CUDADeviceApproxTranscendentals = 1;
  1761. if (Opts.ObjC1) {
  1762. if (Arg *arg = Args.getLastArg(OPT_fobjc_runtime_EQ)) {
  1763. StringRef value = arg->getValue();
  1764. if (Opts.ObjCRuntime.tryParse(value))
  1765. Diags.Report(diag::err_drv_unknown_objc_runtime) << value;
  1766. }
  1767. if (Args.hasArg(OPT_fobjc_gc_only))
  1768. Opts.setGC(LangOptions::GCOnly);
  1769. else if (Args.hasArg(OPT_fobjc_gc))
  1770. Opts.setGC(LangOptions::HybridGC);
  1771. else if (Args.hasArg(OPT_fobjc_arc)) {
  1772. Opts.ObjCAutoRefCount = 1;
  1773. if (!Opts.ObjCRuntime.allowsARC())
  1774. Diags.Report(diag::err_arc_unsupported_on_runtime);
  1775. }
  1776. // ObjCWeakRuntime tracks whether the runtime supports __weak, not
  1777. // whether the feature is actually enabled. This is predominantly
  1778. // determined by -fobjc-runtime, but we allow it to be overridden
  1779. // from the command line for testing purposes.
  1780. if (Args.hasArg(OPT_fobjc_runtime_has_weak))
  1781. Opts.ObjCWeakRuntime = 1;
  1782. else
  1783. Opts.ObjCWeakRuntime = Opts.ObjCRuntime.allowsWeak();
  1784. // ObjCWeak determines whether __weak is actually enabled.
  1785. // Note that we allow -fno-objc-weak to disable this even in ARC mode.
  1786. if (auto weakArg = Args.getLastArg(OPT_fobjc_weak, OPT_fno_objc_weak)) {
  1787. if (!weakArg->getOption().matches(OPT_fobjc_weak)) {
  1788. assert(!Opts.ObjCWeak);
  1789. } else if (Opts.getGC() != LangOptions::NonGC) {
  1790. Diags.Report(diag::err_objc_weak_with_gc);
  1791. } else if (!Opts.ObjCWeakRuntime) {
  1792. Diags.Report(diag::err_objc_weak_unsupported);
  1793. } else {
  1794. Opts.ObjCWeak = 1;
  1795. }
  1796. } else if (Opts.ObjCAutoRefCount) {
  1797. Opts.ObjCWeak = Opts.ObjCWeakRuntime;
  1798. }
  1799. if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
  1800. Opts.ObjCInferRelatedResultType = 0;
  1801. if (Args.hasArg(OPT_fobjc_subscripting_legacy_runtime))
  1802. Opts.ObjCSubscriptingLegacyRuntime =
  1803. (Opts.ObjCRuntime.getKind() == ObjCRuntime::FragileMacOSX);
  1804. }
  1805. if (Args.hasArg(OPT_fgnu89_inline)) {
  1806. if (Opts.CPlusPlus)
  1807. Diags.Report(diag::err_drv_argument_not_allowed_with)
  1808. << "-fgnu89-inline" << GetInputKindName(IK);
  1809. else
  1810. Opts.GNUInline = 1;
  1811. }
  1812. if (Args.hasArg(OPT_fapple_kext)) {
  1813. if (!Opts.CPlusPlus)
  1814. Diags.Report(diag::warn_c_kext);
  1815. else
  1816. Opts.AppleKext = 1;
  1817. }
  1818. if (Args.hasArg(OPT_print_ivar_layout))
  1819. Opts.ObjCGCBitmapPrint = 1;
  1820. if (Args.hasArg(OPT_fno_constant_cfstrings))
  1821. Opts.NoConstantCFStrings = 1;
  1822. if (Args.hasArg(OPT_fzvector))
  1823. Opts.ZVector = 1;
  1824. if (Args.hasArg(OPT_pthread))
  1825. Opts.POSIXThreads = 1;
  1826. // The value-visibility mode defaults to "default".
  1827. if (Arg *visOpt = Args.getLastArg(OPT_fvisibility)) {
  1828. Opts.setValueVisibilityMode(parseVisibility(visOpt, Args, Diags));
  1829. } else {
  1830. Opts.setValueVisibilityMode(DefaultVisibility);
  1831. }
  1832. // The type-visibility mode defaults to the value-visibility mode.
  1833. if (Arg *typeVisOpt = Args.getLastArg(OPT_ftype_visibility)) {
  1834. Opts.setTypeVisibilityMode(parseVisibility(typeVisOpt, Args, Diags));
  1835. } else {
  1836. Opts.setTypeVisibilityMode(Opts.getValueVisibilityMode());
  1837. }
  1838. if (Args.hasArg(OPT_fvisibility_inlines_hidden))
  1839. Opts.InlineVisibilityHidden = 1;
  1840. if (Args.hasArg(OPT_ftrapv)) {
  1841. Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
  1842. // Set the handler, if one is specified.
  1843. Opts.OverflowHandler =
  1844. Args.getLastArgValue(OPT_ftrapv_handler);
  1845. }
  1846. else if (Args.hasArg(OPT_fwrapv))
  1847. Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
  1848. Opts.MSVCCompat = Args.hasArg(OPT_fms_compatibility);
  1849. Opts.MicrosoftExt = Opts.MSVCCompat || Args.hasArg(OPT_fms_extensions);
  1850. Opts.AsmBlocks = Args.hasArg(OPT_fasm_blocks) || Opts.MicrosoftExt;
  1851. Opts.MSCompatibilityVersion = 0;
  1852. if (const Arg *A = Args.getLastArg(OPT_fms_compatibility_version)) {
  1853. VersionTuple VT;
  1854. if (VT.tryParse(A->getValue()))
  1855. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
  1856. << A->getValue();
  1857. Opts.MSCompatibilityVersion = VT.getMajor() * 10000000 +
  1858. VT.getMinor().getValueOr(0) * 100000 +
  1859. VT.getSubminor().getValueOr(0);
  1860. }
  1861. // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
  1862. // is specified, or -std is set to a conforming mode.
  1863. // Trigraphs are disabled by default in c++1z onwards.
  1864. Opts.Trigraphs = !Opts.GNUMode && !Opts.MSVCCompat && !Opts.CPlusPlus1z;
  1865. Opts.Trigraphs =
  1866. Args.hasFlag(OPT_ftrigraphs, OPT_fno_trigraphs, Opts.Trigraphs);
  1867. Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
  1868. OPT_fno_dollars_in_identifiers,
  1869. Opts.DollarIdents);
  1870. Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
  1871. Opts.VtorDispMode = getLastArgIntValue(Args, OPT_vtordisp_mode_EQ, 1, Diags);
  1872. Opts.Borland = Args.hasArg(OPT_fborland_extensions);
  1873. Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
  1874. Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
  1875. Opts.ConstStrings);
  1876. if (Args.hasArg(OPT_fno_lax_vector_conversions))
  1877. Opts.LaxVectorConversions = 0;
  1878. if (Args.hasArg(OPT_fno_threadsafe_statics))
  1879. Opts.ThreadsafeStatics = 0;
  1880. Opts.Exceptions = Args.hasArg(OPT_fexceptions);
  1881. Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
  1882. Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
  1883. Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions);
  1884. Opts.ExternCNoUnwind = Args.hasArg(OPT_fexternc_nounwind);
  1885. Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
  1886. Opts.RTTI = Opts.CPlusPlus && !Args.hasArg(OPT_fno_rtti);
  1887. Opts.RTTIData = Opts.RTTI && !Args.hasArg(OPT_fno_rtti_data);
  1888. Opts.Blocks = Args.hasArg(OPT_fblocks) || (Opts.OpenCL
  1889. && Opts.OpenCLVersion >= 200);
  1890. Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
  1891. Opts.CoroutinesTS = Args.hasArg(OPT_fcoroutines_ts);
  1892. Opts.ModulesTS = Args.hasArg(OPT_fmodules_ts);
  1893. Opts.Modules = Args.hasArg(OPT_fmodules) || Opts.ModulesTS;
  1894. Opts.ModulesStrictDeclUse = Args.hasArg(OPT_fmodules_strict_decluse);
  1895. Opts.ModulesDeclUse =
  1896. Args.hasArg(OPT_fmodules_decluse) || Opts.ModulesStrictDeclUse;
  1897. Opts.ModulesLocalVisibility =
  1898. Args.hasArg(OPT_fmodules_local_submodule_visibility) || Opts.ModulesTS;
  1899. Opts.ModulesCodegen = Args.hasArg(OPT_fmodules_codegen);
  1900. Opts.ModulesDebugInfo = Args.hasArg(OPT_fmodules_debuginfo);
  1901. Opts.ModulesSearchAll = Opts.Modules &&
  1902. !Args.hasArg(OPT_fno_modules_search_all) &&
  1903. Args.hasArg(OPT_fmodules_search_all);
  1904. Opts.ModulesErrorRecovery = !Args.hasArg(OPT_fno_modules_error_recovery);
  1905. Opts.ImplicitModules = !Args.hasArg(OPT_fno_implicit_modules);
  1906. Opts.CharIsSigned = Opts.OpenCL || !Args.hasArg(OPT_fno_signed_char);
  1907. Opts.WChar = Opts.CPlusPlus && !Args.hasArg(OPT_fno_wchar);
  1908. Opts.ShortWChar = Args.hasFlag(OPT_fshort_wchar, OPT_fno_short_wchar, false);
  1909. Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
  1910. Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
  1911. Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
  1912. if (!Opts.NoBuiltin)
  1913. getAllNoBuiltinFuncValues(Args, Opts.NoBuiltinFuncs);
  1914. Opts.NoMathBuiltin = Args.hasArg(OPT_fno_math_builtin);
  1915. Opts.RelaxedTemplateTemplateArgs =
  1916. Args.hasArg(OPT_frelaxed_template_template_args);
  1917. Opts.SizedDeallocation = Args.hasArg(OPT_fsized_deallocation);
  1918. Opts.AlignedAllocation =
  1919. Args.hasFlag(OPT_faligned_allocation, OPT_fno_aligned_allocation,
  1920. Opts.AlignedAllocation);
  1921. Opts.AlignedAllocationUnavailable =
  1922. Opts.AlignedAllocation && Args.hasArg(OPT_aligned_alloc_unavailable);
  1923. Opts.NewAlignOverride =
  1924. getLastArgIntValue(Args, OPT_fnew_alignment_EQ, 0, Diags);
  1925. if (Opts.NewAlignOverride && !llvm::isPowerOf2_32(Opts.NewAlignOverride)) {
  1926. Arg *A = Args.getLastArg(OPT_fnew_alignment_EQ);
  1927. Diags.Report(diag::err_fe_invalid_alignment) << A->getAsString(Args)
  1928. << A->getValue();
  1929. Opts.NewAlignOverride = 0;
  1930. }
  1931. Opts.ConceptsTS = Args.hasArg(OPT_fconcepts_ts);
  1932. Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
  1933. Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
  1934. Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
  1935. Opts.MathErrno = !Opts.OpenCL && Args.hasArg(OPT_fmath_errno);
  1936. Opts.InstantiationDepth =
  1937. getLastArgIntValue(Args, OPT_ftemplate_depth, 1024, Diags);
  1938. Opts.ArrowDepth =
  1939. getLastArgIntValue(Args, OPT_foperator_arrow_depth, 256, Diags);
  1940. Opts.ConstexprCallDepth =
  1941. getLastArgIntValue(Args, OPT_fconstexpr_depth, 512, Diags);
  1942. Opts.ConstexprStepLimit =
  1943. getLastArgIntValue(Args, OPT_fconstexpr_steps, 1048576, Diags);
  1944. Opts.BracketDepth = getLastArgIntValue(Args, OPT_fbracket_depth, 256, Diags);
  1945. Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
  1946. Opts.NumLargeByValueCopy =
  1947. getLastArgIntValue(Args, OPT_Wlarge_by_value_copy_EQ, 0, Diags);
  1948. Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
  1949. Opts.ObjCConstantStringClass =
  1950. Args.getLastArgValue(OPT_fconstant_string_class);
  1951. Opts.ObjCDefaultSynthProperties =
  1952. !Args.hasArg(OPT_disable_objc_default_synthesize_properties);
  1953. Opts.EncodeExtendedBlockSig =
  1954. Args.hasArg(OPT_fencode_extended_block_signature);
  1955. Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
  1956. Opts.PackStruct = getLastArgIntValue(Args, OPT_fpack_struct_EQ, 0, Diags);
  1957. Opts.MaxTypeAlign = getLastArgIntValue(Args, OPT_fmax_type_align_EQ, 0, Diags);
  1958. Opts.AlignDouble = Args.hasArg(OPT_malign_double);
  1959. Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
  1960. Opts.PIE = Args.hasArg(OPT_pic_is_pie);
  1961. Opts.Static = Args.hasArg(OPT_static_define);
  1962. Opts.DumpRecordLayoutsSimple = Args.hasArg(OPT_fdump_record_layouts_simple);
  1963. Opts.DumpRecordLayouts = Opts.DumpRecordLayoutsSimple
  1964. || Args.hasArg(OPT_fdump_record_layouts);
  1965. Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
  1966. Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
  1967. Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
  1968. Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
  1969. Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
  1970. Opts.HexagonQdsp6Compat = Args.hasArg(OPT_mqdsp6_compat);
  1971. Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
  1972. Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
  1973. Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
  1974. Opts.DebuggerCastResultToId = Args.hasArg(OPT_fdebugger_cast_result_to_id);
  1975. Opts.DebuggerObjCLiteral = Args.hasArg(OPT_fdebugger_objc_literal);
  1976. Opts.ApplePragmaPack = Args.hasArg(OPT_fapple_pragma_pack);
  1977. Opts.CurrentModule = Args.getLastArgValue(OPT_fmodule_name_EQ);
  1978. Opts.AppExt = Args.hasArg(OPT_fapplication_extension);
  1979. Opts.ModuleFeatures = Args.getAllArgValues(OPT_fmodule_feature);
  1980. std::sort(Opts.ModuleFeatures.begin(), Opts.ModuleFeatures.end());
  1981. Opts.NativeHalfType |= Args.hasArg(OPT_fnative_half_type);
  1982. Opts.NativeHalfArgsAndReturns |= Args.hasArg(OPT_fnative_half_arguments_and_returns);
  1983. // Enable HalfArgsAndReturns if present in Args or if NativeHalfArgsAndReturns
  1984. // is enabled.
  1985. Opts.HalfArgsAndReturns = Args.hasArg(OPT_fallow_half_arguments_and_returns)
  1986. | Opts.NativeHalfArgsAndReturns;
  1987. Opts.GNUAsm = !Args.hasArg(OPT_fno_gnu_inline_asm);
  1988. // __declspec is enabled by default for the PS4 by the driver, and also
  1989. // enabled for Microsoft Extensions or Borland Extensions, here.
  1990. //
  1991. // FIXME: __declspec is also currently enabled for CUDA, but isn't really a
  1992. // CUDA extension. However, it is required for supporting
  1993. // __clang_cuda_builtin_vars.h, which uses __declspec(property). Once that has
  1994. // been rewritten in terms of something more generic, remove the Opts.CUDA
  1995. // term here.
  1996. Opts.DeclSpecKeyword =
  1997. Args.hasFlag(OPT_fdeclspec, OPT_fno_declspec,
  1998. (Opts.MicrosoftExt || Opts.Borland || Opts.CUDA));
  1999. if (Arg *A = Args.getLastArg(OPT_faddress_space_map_mangling_EQ)) {
  2000. switch (llvm::StringSwitch<unsigned>(A->getValue())
  2001. .Case("target", LangOptions::ASMM_Target)
  2002. .Case("no", LangOptions::ASMM_Off)
  2003. .Case("yes", LangOptions::ASMM_On)
  2004. .Default(255)) {
  2005. default:
  2006. Diags.Report(diag::err_drv_invalid_value)
  2007. << "-faddress-space-map-mangling=" << A->getValue();
  2008. break;
  2009. case LangOptions::ASMM_Target:
  2010. Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Target);
  2011. break;
  2012. case LangOptions::ASMM_On:
  2013. Opts.setAddressSpaceMapMangling(LangOptions::ASMM_On);
  2014. break;
  2015. case LangOptions::ASMM_Off:
  2016. Opts.setAddressSpaceMapMangling(LangOptions::ASMM_Off);
  2017. break;
  2018. }
  2019. }
  2020. if (Arg *A = Args.getLastArg(OPT_fms_memptr_rep_EQ)) {
  2021. LangOptions::PragmaMSPointersToMembersKind InheritanceModel =
  2022. llvm::StringSwitch<LangOptions::PragmaMSPointersToMembersKind>(
  2023. A->getValue())
  2024. .Case("single",
  2025. LangOptions::PPTMK_FullGeneralitySingleInheritance)
  2026. .Case("multiple",
  2027. LangOptions::PPTMK_FullGeneralityMultipleInheritance)
  2028. .Case("virtual",
  2029. LangOptions::PPTMK_FullGeneralityVirtualInheritance)
  2030. .Default(LangOptions::PPTMK_BestCase);
  2031. if (InheritanceModel == LangOptions::PPTMK_BestCase)
  2032. Diags.Report(diag::err_drv_invalid_value)
  2033. << "-fms-memptr-rep=" << A->getValue();
  2034. Opts.setMSPointerToMemberRepresentationMethod(InheritanceModel);
  2035. }
  2036. // Check for MS default calling conventions being specified.
  2037. if (Arg *A = Args.getLastArg(OPT_fdefault_calling_conv_EQ)) {
  2038. LangOptions::DefaultCallingConvention DefaultCC =
  2039. llvm::StringSwitch<LangOptions::DefaultCallingConvention>(
  2040. A->getValue())
  2041. .Case("cdecl", LangOptions::DCC_CDecl)
  2042. .Case("fastcall", LangOptions::DCC_FastCall)
  2043. .Case("stdcall", LangOptions::DCC_StdCall)
  2044. .Case("vectorcall", LangOptions::DCC_VectorCall)
  2045. .Default(LangOptions::DCC_None);
  2046. if (DefaultCC == LangOptions::DCC_None)
  2047. Diags.Report(diag::err_drv_invalid_value)
  2048. << "-fdefault-calling-conv=" << A->getValue();
  2049. llvm::Triple T(TargetOpts.Triple);
  2050. llvm::Triple::ArchType Arch = T.getArch();
  2051. bool emitError = (DefaultCC == LangOptions::DCC_FastCall ||
  2052. DefaultCC == LangOptions::DCC_StdCall) &&
  2053. Arch != llvm::Triple::x86;
  2054. emitError |= DefaultCC == LangOptions::DCC_VectorCall &&
  2055. !(Arch == llvm::Triple::x86 || Arch == llvm::Triple::x86_64);
  2056. if (emitError)
  2057. Diags.Report(diag::err_drv_argument_not_allowed_with)
  2058. << A->getSpelling() << T.getTriple();
  2059. else
  2060. Opts.setDefaultCallingConv(DefaultCC);
  2061. }
  2062. // -mrtd option
  2063. if (Arg *A = Args.getLastArg(OPT_mrtd)) {
  2064. if (Opts.getDefaultCallingConv() != LangOptions::DCC_None)
  2065. Diags.Report(diag::err_drv_argument_not_allowed_with)
  2066. << A->getSpelling() << "-fdefault-calling-conv";
  2067. else {
  2068. llvm::Triple T(TargetOpts.Triple);
  2069. if (T.getArch() != llvm::Triple::x86)
  2070. Diags.Report(diag::err_drv_argument_not_allowed_with)
  2071. << A->getSpelling() << T.getTriple();
  2072. else
  2073. Opts.setDefaultCallingConv(LangOptions::DCC_StdCall);
  2074. }
  2075. }
  2076. // Check if -fopenmp is specified.
  2077. Opts.OpenMP = Args.hasArg(options::OPT_fopenmp) ? 1 : 0;
  2078. Opts.OpenMPUseTLS =
  2079. Opts.OpenMP && !Args.hasArg(options::OPT_fnoopenmp_use_tls);
  2080. Opts.OpenMPIsDevice =
  2081. Opts.OpenMP && Args.hasArg(options::OPT_fopenmp_is_device);
  2082. if (Opts.OpenMP) {
  2083. int Version =
  2084. getLastArgIntValue(Args, OPT_fopenmp_version_EQ, Opts.OpenMP, Diags);
  2085. if (Version != 0)
  2086. Opts.OpenMP = Version;
  2087. // Provide diagnostic when a given target is not expected to be an OpenMP
  2088. // device or host.
  2089. if (!Opts.OpenMPIsDevice) {
  2090. switch (T.getArch()) {
  2091. default:
  2092. break;
  2093. // Add unsupported host targets here:
  2094. case llvm::Triple::nvptx:
  2095. case llvm::Triple::nvptx64:
  2096. Diags.Report(clang::diag::err_drv_omp_host_target_not_supported)
  2097. << TargetOpts.Triple;
  2098. break;
  2099. }
  2100. }
  2101. }
  2102. // Get the OpenMP target triples if any.
  2103. if (Arg *A = Args.getLastArg(options::OPT_fopenmp_targets_EQ)) {
  2104. for (unsigned i = 0; i < A->getNumValues(); ++i) {
  2105. llvm::Triple TT(A->getValue(i));
  2106. if (TT.getArch() == llvm::Triple::UnknownArch)
  2107. Diags.Report(clang::diag::err_drv_invalid_omp_target) << A->getValue(i);
  2108. else
  2109. Opts.OMPTargetTriples.push_back(TT);
  2110. }
  2111. }
  2112. // Get OpenMP host file path if any and report if a non existent file is
  2113. // found
  2114. if (Arg *A = Args.getLastArg(options::OPT_fopenmp_host_ir_file_path)) {
  2115. Opts.OMPHostIRFile = A->getValue();
  2116. if (!llvm::sys::fs::exists(Opts.OMPHostIRFile))
  2117. Diags.Report(clang::diag::err_drv_omp_host_ir_file_not_found)
  2118. << Opts.OMPHostIRFile;
  2119. }
  2120. // Record whether the __DEPRECATED define was requested.
  2121. Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
  2122. OPT_fno_deprecated_macro,
  2123. Opts.Deprecated);
  2124. // FIXME: Eliminate this dependency.
  2125. unsigned Opt = getOptimizationLevel(Args, IK, Diags),
  2126. OptSize = getOptimizationLevelSize(Args);
  2127. Opts.Optimize = Opt != 0;
  2128. Opts.OptimizeSize = OptSize != 0;
  2129. // This is the __NO_INLINE__ define, which just depends on things like the
  2130. // optimization level and -fno-inline, not actually whether the backend has
  2131. // inlining enabled.
  2132. Opts.NoInlineDefine = !Opts.Optimize;
  2133. if (Arg *InlineArg = Args.getLastArg(
  2134. options::OPT_finline_functions, options::OPT_finline_hint_functions,
  2135. options::OPT_fno_inline_functions, options::OPT_fno_inline))
  2136. if (InlineArg->getOption().matches(options::OPT_fno_inline))
  2137. Opts.NoInlineDefine = true;
  2138. Opts.FastMath = Args.hasArg(OPT_ffast_math) ||
  2139. Args.hasArg(OPT_cl_fast_relaxed_math);
  2140. Opts.FiniteMathOnly = Args.hasArg(OPT_ffinite_math_only) ||
  2141. Args.hasArg(OPT_cl_finite_math_only) ||
  2142. Args.hasArg(OPT_cl_fast_relaxed_math);
  2143. Opts.UnsafeFPMath = Args.hasArg(OPT_menable_unsafe_fp_math) ||
  2144. Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
  2145. Args.hasArg(OPT_cl_fast_relaxed_math);
  2146. if (Arg *A = Args.getLastArg(OPT_ffp_contract)) {
  2147. StringRef Val = A->getValue();
  2148. if (Val == "fast")
  2149. Opts.setDefaultFPContractMode(LangOptions::FPC_Fast);
  2150. else if (Val == "on")
  2151. Opts.setDefaultFPContractMode(LangOptions::FPC_On);
  2152. else if (Val == "off")
  2153. Opts.setDefaultFPContractMode(LangOptions::FPC_Off);
  2154. else
  2155. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
  2156. }
  2157. Opts.RetainCommentsFromSystemHeaders =
  2158. Args.hasArg(OPT_fretain_comments_from_system_headers);
  2159. unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
  2160. switch (SSP) {
  2161. default:
  2162. Diags.Report(diag::err_drv_invalid_value)
  2163. << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
  2164. break;
  2165. case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
  2166. case 1: Opts.setStackProtector(LangOptions::SSPOn); break;
  2167. case 2: Opts.setStackProtector(LangOptions::SSPStrong); break;
  2168. case 3: Opts.setStackProtector(LangOptions::SSPReq); break;
  2169. }
  2170. // Parse -fsanitize= arguments.
  2171. parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
  2172. Diags, Opts.Sanitize);
  2173. // -fsanitize-address-field-padding=N has to be a LangOpt, parse it here.
  2174. Opts.SanitizeAddressFieldPadding =
  2175. getLastArgIntValue(Args, OPT_fsanitize_address_field_padding, 0, Diags);
  2176. Opts.SanitizerBlacklistFiles = Args.getAllArgValues(OPT_fsanitize_blacklist);
  2177. // -fxray-instrument
  2178. Opts.XRayInstrument =
  2179. Args.hasFlag(OPT_fxray_instrument, OPT_fnoxray_instrument, false);
  2180. // -fxray-{always,never}-instrument= filenames.
  2181. Opts.XRayAlwaysInstrumentFiles =
  2182. Args.getAllArgValues(OPT_fxray_always_instrument);
  2183. Opts.XRayNeverInstrumentFiles =
  2184. Args.getAllArgValues(OPT_fxray_never_instrument);
  2185. // -fallow-editor-placeholders
  2186. Opts.AllowEditorPlaceholders = Args.hasArg(OPT_fallow_editor_placeholders);
  2187. }
  2188. static bool isStrictlyPreprocessorAction(frontend::ActionKind Action) {
  2189. switch (Action) {
  2190. case frontend::ASTDeclList:
  2191. case frontend::ASTDump:
  2192. case frontend::ASTPrint:
  2193. case frontend::ASTView:
  2194. case frontend::EmitAssembly:
  2195. case frontend::EmitBC:
  2196. case frontend::EmitHTML:
  2197. case frontend::EmitLLVM:
  2198. case frontend::EmitLLVMOnly:
  2199. case frontend::EmitCodeGenOnly:
  2200. case frontend::EmitObj:
  2201. case frontend::FixIt:
  2202. case frontend::GenerateModule:
  2203. case frontend::GenerateModuleInterface:
  2204. case frontend::GeneratePCH:
  2205. case frontend::GeneratePTH:
  2206. case frontend::ParseSyntaxOnly:
  2207. case frontend::ModuleFileInfo:
  2208. case frontend::VerifyPCH:
  2209. case frontend::PluginAction:
  2210. case frontend::PrintDeclContext:
  2211. case frontend::RewriteObjC:
  2212. case frontend::RewriteTest:
  2213. case frontend::RunAnalysis:
  2214. case frontend::MigrateSource:
  2215. return false;
  2216. case frontend::DumpRawTokens:
  2217. case frontend::DumpTokens:
  2218. case frontend::InitOnly:
  2219. case frontend::PrintPreamble:
  2220. case frontend::PrintPreprocessedInput:
  2221. case frontend::RewriteMacros:
  2222. case frontend::RunPreprocessorOnly:
  2223. return true;
  2224. }
  2225. llvm_unreachable("invalid frontend action");
  2226. }
  2227. static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
  2228. FileManager &FileMgr,
  2229. DiagnosticsEngine &Diags,
  2230. frontend::ActionKind Action) {
  2231. using namespace options;
  2232. Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
  2233. Opts.ImplicitPTHInclude = Args.getLastArgValue(OPT_include_pth);
  2234. if (const Arg *A = Args.getLastArg(OPT_token_cache))
  2235. Opts.TokenCache = A->getValue();
  2236. else
  2237. Opts.TokenCache = Opts.ImplicitPTHInclude;
  2238. Opts.UsePredefines = !Args.hasArg(OPT_undef);
  2239. Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
  2240. Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
  2241. Opts.AllowPCHWithCompilerErrors = Args.hasArg(OPT_fallow_pch_with_errors);
  2242. Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
  2243. for (const Arg *A : Args.filtered(OPT_error_on_deserialized_pch_decl))
  2244. Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue());
  2245. if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
  2246. StringRef Value(A->getValue());
  2247. size_t Comma = Value.find(',');
  2248. unsigned Bytes = 0;
  2249. unsigned EndOfLine = 0;
  2250. if (Comma == StringRef::npos ||
  2251. Value.substr(0, Comma).getAsInteger(10, Bytes) ||
  2252. Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
  2253. Diags.Report(diag::err_drv_preamble_format);
  2254. else {
  2255. Opts.PrecompiledPreambleBytes.first = Bytes;
  2256. Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
  2257. }
  2258. }
  2259. // Add macros from the command line.
  2260. for (const Arg *A : Args.filtered(OPT_D, OPT_U)) {
  2261. if (A->getOption().matches(OPT_D))
  2262. Opts.addMacroDef(A->getValue());
  2263. else
  2264. Opts.addMacroUndef(A->getValue());
  2265. }
  2266. Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
  2267. // Add the ordered list of -includes.
  2268. for (const Arg *A : Args.filtered(OPT_include))
  2269. Opts.Includes.emplace_back(A->getValue());
  2270. for (const Arg *A : Args.filtered(OPT_chain_include))
  2271. Opts.ChainedIncludes.emplace_back(A->getValue());
  2272. for (const Arg *A : Args.filtered(OPT_remap_file)) {
  2273. std::pair<StringRef, StringRef> Split = StringRef(A->getValue()).split(';');
  2274. if (Split.second.empty()) {
  2275. Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
  2276. continue;
  2277. }
  2278. Opts.addRemappedFile(Split.first, Split.second);
  2279. }
  2280. if (Arg *A = Args.getLastArg(OPT_fobjc_arc_cxxlib_EQ)) {
  2281. StringRef Name = A->getValue();
  2282. unsigned Library = llvm::StringSwitch<unsigned>(Name)
  2283. .Case("libc++", ARCXX_libcxx)
  2284. .Case("libstdc++", ARCXX_libstdcxx)
  2285. .Case("none", ARCXX_nolib)
  2286. .Default(~0U);
  2287. if (Library == ~0U)
  2288. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
  2289. else
  2290. Opts.ObjCXXARCStandardLibrary = (ObjCXXARCStandardLibraryKind)Library;
  2291. }
  2292. // Always avoid lexing editor placeholders when we're just running the
  2293. // preprocessor as we never want to emit the
  2294. // "editor placeholder in source file" error in PP only mode.
  2295. if (isStrictlyPreprocessorAction(Action))
  2296. Opts.LexEditorPlaceholders = false;
  2297. }
  2298. static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
  2299. ArgList &Args,
  2300. frontend::ActionKind Action) {
  2301. using namespace options;
  2302. if (isStrictlyPreprocessorAction(Action))
  2303. Opts.ShowCPP = !Args.hasArg(OPT_dM);
  2304. else
  2305. Opts.ShowCPP = 0;
  2306. Opts.ShowComments = Args.hasArg(OPT_C);
  2307. Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
  2308. Opts.ShowMacroComments = Args.hasArg(OPT_CC);
  2309. Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
  2310. Opts.ShowIncludeDirectives = Args.hasArg(OPT_dI);
  2311. Opts.RewriteIncludes = Args.hasArg(OPT_frewrite_includes);
  2312. Opts.RewriteImports = Args.hasArg(OPT_frewrite_imports);
  2313. Opts.UseLineDirectives = Args.hasArg(OPT_fuse_line_directives);
  2314. }
  2315. static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
  2316. DiagnosticsEngine &Diags) {
  2317. using namespace options;
  2318. Opts.ABI = Args.getLastArgValue(OPT_target_abi);
  2319. if (Arg *A = Args.getLastArg(OPT_meabi)) {
  2320. StringRef Value = A->getValue();
  2321. llvm::EABI EABIVersion = llvm::StringSwitch<llvm::EABI>(Value)
  2322. .Case("default", llvm::EABI::Default)
  2323. .Case("4", llvm::EABI::EABI4)
  2324. .Case("5", llvm::EABI::EABI5)
  2325. .Case("gnu", llvm::EABI::GNU)
  2326. .Default(llvm::EABI::Unknown);
  2327. if (EABIVersion == llvm::EABI::Unknown)
  2328. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
  2329. << Value;
  2330. else
  2331. Opts.EABIVersion = EABIVersion;
  2332. }
  2333. Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
  2334. Opts.FPMath = Args.getLastArgValue(OPT_mfpmath);
  2335. Opts.FeaturesAsWritten = Args.getAllArgValues(OPT_target_feature);
  2336. Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
  2337. Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
  2338. Opts.Reciprocals = Args.getAllArgValues(OPT_mrecip_EQ);
  2339. // Use the default target triple if unspecified.
  2340. if (Opts.Triple.empty())
  2341. Opts.Triple = llvm::sys::getDefaultTargetTriple();
  2342. Opts.OpenCLExtensionsAsWritten = Args.getAllArgValues(OPT_cl_ext_EQ);
  2343. }
  2344. bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
  2345. const char *const *ArgBegin,
  2346. const char *const *ArgEnd,
  2347. DiagnosticsEngine &Diags) {
  2348. bool Success = true;
  2349. // Parse the arguments.
  2350. std::unique_ptr<OptTable> Opts = createDriverOptTable();
  2351. const unsigned IncludedFlagsBitmask = options::CC1Option;
  2352. unsigned MissingArgIndex, MissingArgCount;
  2353. InputArgList Args =
  2354. Opts->ParseArgs(llvm::makeArrayRef(ArgBegin, ArgEnd), MissingArgIndex,
  2355. MissingArgCount, IncludedFlagsBitmask);
  2356. LangOptions &LangOpts = *Res.getLangOpts();
  2357. // Check for missing argument error.
  2358. if (MissingArgCount) {
  2359. Diags.Report(diag::err_drv_missing_argument)
  2360. << Args.getArgString(MissingArgIndex) << MissingArgCount;
  2361. Success = false;
  2362. }
  2363. // Issue errors on unknown arguments.
  2364. for (const Arg *A : Args.filtered(OPT_UNKNOWN)) {
  2365. Diags.Report(diag::err_drv_unknown_argument) << A->getAsString(Args);
  2366. Success = false;
  2367. }
  2368. Success &= ParseAnalyzerArgs(*Res.getAnalyzerOpts(), Args, Diags);
  2369. Success &= ParseMigratorArgs(Res.getMigratorOpts(), Args);
  2370. ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), Args);
  2371. Success &=
  2372. ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags,
  2373. false /*DefaultDiagColor*/, false /*DefaultShowOpt*/);
  2374. ParseCommentArgs(LangOpts.CommentOpts, Args);
  2375. ParseFileSystemArgs(Res.getFileSystemOpts(), Args);
  2376. // FIXME: We shouldn't have to pass the DashX option around here
  2377. InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags,
  2378. LangOpts.IsHeaderFile);
  2379. ParseTargetArgs(Res.getTargetOpts(), Args, Diags);
  2380. Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags,
  2381. Res.getTargetOpts());
  2382. ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args,
  2383. Res.getFileSystemOpts().WorkingDir);
  2384. if (DashX.getFormat() == InputKind::Precompiled ||
  2385. DashX.getLanguage() == InputKind::LLVM_IR) {
  2386. // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the
  2387. // PassManager in BackendUtil.cpp. They need to be initializd no matter
  2388. // what the input type is.
  2389. if (Args.hasArg(OPT_fobjc_arc))
  2390. LangOpts.ObjCAutoRefCount = 1;
  2391. // PIClevel and PIELevel are needed during code generation and this should be
  2392. // set regardless of the input type.
  2393. LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
  2394. LangOpts.PIE = Args.hasArg(OPT_pic_is_pie);
  2395. parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
  2396. Diags, LangOpts.Sanitize);
  2397. } else {
  2398. // Other LangOpts are only initialzed when the input is not AST or LLVM IR.
  2399. // FIXME: Should we really be calling this for an InputKind::Asm input?
  2400. ParseLangArgs(LangOpts, Args, DashX, Res.getTargetOpts(),
  2401. Res.getPreprocessorOpts(), Diags);
  2402. if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
  2403. LangOpts.ObjCExceptions = 1;
  2404. }
  2405. if (LangOpts.CUDA) {
  2406. // During CUDA device-side compilation, the aux triple is the
  2407. // triple used for host compilation.
  2408. if (LangOpts.CUDAIsDevice)
  2409. Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
  2410. }
  2411. // Set the triple of the host for OpenMP device compile.
  2412. if (LangOpts.OpenMPIsDevice)
  2413. Res.getTargetOpts().HostTriple = Res.getFrontendOpts().AuxTriple;
  2414. // FIXME: Override value name discarding when asan or msan is used because the
  2415. // backend passes depend on the name of the alloca in order to print out
  2416. // names.
  2417. Res.getCodeGenOpts().DiscardValueNames &=
  2418. !LangOpts.Sanitize.has(SanitizerKind::Address) &&
  2419. !LangOpts.Sanitize.has(SanitizerKind::Memory);
  2420. // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
  2421. // PCH file and find the original header name. Remove the need to do that in
  2422. // ParsePreprocessorArgs and remove the FileManager
  2423. // parameters from the function and the "FileManager.h" #include.
  2424. FileManager FileMgr(Res.getFileSystemOpts());
  2425. ParsePreprocessorArgs(Res.getPreprocessorOpts(), Args, FileMgr, Diags,
  2426. Res.getFrontendOpts().ProgramAction);
  2427. ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), Args,
  2428. Res.getFrontendOpts().ProgramAction);
  2429. // Turn on -Wspir-compat for SPIR target.
  2430. llvm::Triple T(Res.getTargetOpts().Triple);
  2431. auto Arch = T.getArch();
  2432. if (Arch == llvm::Triple::spir || Arch == llvm::Triple::spir64) {
  2433. Res.getDiagnosticOpts().Warnings.push_back("spir-compat");
  2434. }
  2435. return Success;
  2436. }
  2437. std::string CompilerInvocation::getModuleHash() const {
  2438. // Note: For QoI reasons, the things we use as a hash here should all be
  2439. // dumped via the -module-info flag.
  2440. using llvm::hash_code;
  2441. using llvm::hash_value;
  2442. using llvm::hash_combine;
  2443. // Start the signature with the compiler version.
  2444. // FIXME: We'd rather use something more cryptographically sound than
  2445. // CityHash, but this will do for now.
  2446. hash_code code = hash_value(getClangFullRepositoryVersion());
  2447. // Extend the signature with the language options
  2448. #define LANGOPT(Name, Bits, Default, Description) \
  2449. code = hash_combine(code, LangOpts->Name);
  2450. #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
  2451. code = hash_combine(code, static_cast<unsigned>(LangOpts->get##Name()));
  2452. #define BENIGN_LANGOPT(Name, Bits, Default, Description)
  2453. #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
  2454. #include "clang/Basic/LangOptions.def"
  2455. for (StringRef Feature : LangOpts->ModuleFeatures)
  2456. code = hash_combine(code, Feature);
  2457. // Extend the signature with the target options.
  2458. code = hash_combine(code, TargetOpts->Triple, TargetOpts->CPU,
  2459. TargetOpts->ABI);
  2460. for (unsigned i = 0, n = TargetOpts->FeaturesAsWritten.size(); i != n; ++i)
  2461. code = hash_combine(code, TargetOpts->FeaturesAsWritten[i]);
  2462. // Extend the signature with preprocessor options.
  2463. const PreprocessorOptions &ppOpts = getPreprocessorOpts();
  2464. const HeaderSearchOptions &hsOpts = getHeaderSearchOpts();
  2465. code = hash_combine(code, ppOpts.UsePredefines, ppOpts.DetailedRecord);
  2466. for (std::vector<std::pair<std::string, bool/*isUndef*/>>::const_iterator
  2467. I = getPreprocessorOpts().Macros.begin(),
  2468. IEnd = getPreprocessorOpts().Macros.end();
  2469. I != IEnd; ++I) {
  2470. // If we're supposed to ignore this macro for the purposes of modules,
  2471. // don't put it into the hash.
  2472. if (!hsOpts.ModulesIgnoreMacros.empty()) {
  2473. // Check whether we're ignoring this macro.
  2474. StringRef MacroDef = I->first;
  2475. if (hsOpts.ModulesIgnoreMacros.count(
  2476. llvm::CachedHashString(MacroDef.split('=').first)))
  2477. continue;
  2478. }
  2479. code = hash_combine(code, I->first, I->second);
  2480. }
  2481. // Extend the signature with the sysroot and other header search options.
  2482. code = hash_combine(code, hsOpts.Sysroot,
  2483. hsOpts.ModuleFormat,
  2484. hsOpts.UseDebugInfo,
  2485. hsOpts.UseBuiltinIncludes,
  2486. hsOpts.UseStandardSystemIncludes,
  2487. hsOpts.UseStandardCXXIncludes,
  2488. hsOpts.UseLibcxx,
  2489. hsOpts.ModulesValidateDiagnosticOptions);
  2490. code = hash_combine(code, hsOpts.ResourceDir);
  2491. // Extend the signature with the user build path.
  2492. code = hash_combine(code, hsOpts.ModuleUserBuildPath);
  2493. // Extend the signature with the module file extensions.
  2494. const FrontendOptions &frontendOpts = getFrontendOpts();
  2495. for (const auto &ext : frontendOpts.ModuleFileExtensions) {
  2496. code = ext->hashExtension(code);
  2497. }
  2498. // Extend the signature with the enabled sanitizers, if at least one is
  2499. // enabled. Sanitizers which cannot affect AST generation aren't hashed.
  2500. SanitizerSet SanHash = LangOpts->Sanitize;
  2501. SanHash.clear(getPPTransparentSanitizers());
  2502. if (!SanHash.empty())
  2503. code = hash_combine(code, SanHash.Mask);
  2504. return llvm::APInt(64, code).toString(36, /*Signed=*/false);
  2505. }
  2506. namespace clang {
  2507. template<typename IntTy>
  2508. static IntTy getLastArgIntValueImpl(const ArgList &Args, OptSpecifier Id,
  2509. IntTy Default,
  2510. DiagnosticsEngine *Diags) {
  2511. IntTy Res = Default;
  2512. if (Arg *A = Args.getLastArg(Id)) {
  2513. if (StringRef(A->getValue()).getAsInteger(10, Res)) {
  2514. if (Diags)
  2515. Diags->Report(diag::err_drv_invalid_int_value) << A->getAsString(Args)
  2516. << A->getValue();
  2517. }
  2518. }
  2519. return Res;
  2520. }
  2521. // Declared in clang/Frontend/Utils.h.
  2522. int getLastArgIntValue(const ArgList &Args, OptSpecifier Id, int Default,
  2523. DiagnosticsEngine *Diags) {
  2524. return getLastArgIntValueImpl<int>(Args, Id, Default, Diags);
  2525. }
  2526. uint64_t getLastArgUInt64Value(const ArgList &Args, OptSpecifier Id,
  2527. uint64_t Default,
  2528. DiagnosticsEngine *Diags) {
  2529. return getLastArgIntValueImpl<uint64_t>(Args, Id, Default, Diags);
  2530. }
  2531. void BuryPointer(const void *Ptr) {
  2532. // This function may be called only a small fixed amount of times per each
  2533. // invocation, otherwise we do actually have a leak which we want to report.
  2534. // If this function is called more than kGraveYardMaxSize times, the pointers
  2535. // will not be properly buried and a leak detector will report a leak, which
  2536. // is what we want in such case.
  2537. static const size_t kGraveYardMaxSize = 16;
  2538. LLVM_ATTRIBUTE_UNUSED static const void *GraveYard[kGraveYardMaxSize];
  2539. static std::atomic<unsigned> GraveYardSize;
  2540. unsigned Idx = GraveYardSize++;
  2541. if (Idx >= kGraveYardMaxSize)
  2542. return;
  2543. GraveYard[Idx] = Ptr;
  2544. }
  2545. IntrusiveRefCntPtr<vfs::FileSystem>
  2546. createVFSFromCompilerInvocation(const CompilerInvocation &CI,
  2547. DiagnosticsEngine &Diags) {
  2548. return createVFSFromCompilerInvocation(CI, Diags, vfs::getRealFileSystem());
  2549. }
  2550. IntrusiveRefCntPtr<vfs::FileSystem>
  2551. createVFSFromCompilerInvocation(const CompilerInvocation &CI,
  2552. DiagnosticsEngine &Diags,
  2553. IntrusiveRefCntPtr<vfs::FileSystem> BaseFS) {
  2554. if (CI.getHeaderSearchOpts().VFSOverlayFiles.empty())
  2555. return BaseFS;
  2556. IntrusiveRefCntPtr<vfs::OverlayFileSystem> Overlay(
  2557. new vfs::OverlayFileSystem(BaseFS));
  2558. // earlier vfs files are on the bottom
  2559. for (const std::string &File : CI.getHeaderSearchOpts().VFSOverlayFiles) {
  2560. llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> Buffer =
  2561. BaseFS->getBufferForFile(File);
  2562. if (!Buffer) {
  2563. Diags.Report(diag::err_missing_vfs_overlay_file) << File;
  2564. return IntrusiveRefCntPtr<vfs::FileSystem>();
  2565. }
  2566. IntrusiveRefCntPtr<vfs::FileSystem> FS = vfs::getVFSFromYAML(
  2567. std::move(Buffer.get()), /*DiagHandler*/ nullptr, File);
  2568. if (!FS.get()) {
  2569. Diags.Report(diag::err_invalid_vfs_overlay) << File;
  2570. return IntrusiveRefCntPtr<vfs::FileSystem>();
  2571. }
  2572. Overlay->pushOverlay(FS);
  2573. }
  2574. return Overlay;
  2575. }
  2576. } // end namespace clang