CompilerInvocation.cpp 142 KB

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