CompilerInvocation.cpp 148 KB

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