CompilerInvocation.cpp 75 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585158615871588158915901591159215931594159515961597159815991600160116021603160416051606160716081609161016111612161316141615161616171618161916201621162216231624162516261627162816291630163116321633163416351636163716381639164016411642164316441645164616471648164916501651165216531654165516561657165816591660166116621663166416651666166716681669167016711672167316741675167616771678167916801681168216831684168516861687168816891690169116921693169416951696169716981699170017011702170317041705170617071708170917101711171217131714171517161717171817191720172117221723172417251726172717281729173017311732173317341735173617371738173917401741174217431744174517461747174817491750175117521753175417551756175717581759176017611762176317641765176617671768176917701771177217731774177517761777177817791780178117821783178417851786178717881789179017911792179317941795179617971798179918001801180218031804180518061807180818091810181118121813181418151816181718181819182018211822182318241825182618271828182918301831183218331834183518361837183818391840184118421843184418451846184718481849185018511852185318541855185618571858185918601861186218631864186518661867186818691870187118721873187418751876187718781879188018811882188318841885188618871888188918901891189218931894189518961897189818991900190119021903190419051906190719081909191019111912191319141915191619171918191919201921192219231924192519261927192819291930193119321933193419351936193719381939194019411942194319441945194619471948194919501951195219531954195519561957195819591960196119621963196419651966196719681969197019711972197319741975197619771978197919801981198219831984198519861987198819891990199119921993199419951996199719981999200020012002200320042005200620072008200920102011201220132014201520162017201820192020202120222023202420252026202720282029
  1. //===--- CompilerInvocation.cpp -------------------------------------------===//
  2. //
  3. // The LLVM Compiler Infrastructure
  4. //
  5. // This file is distributed under the University of Illinois Open Source
  6. // License. See LICENSE.TXT for details.
  7. //
  8. //===----------------------------------------------------------------------===//
  9. #include "clang/Frontend/CompilerInvocation.h"
  10. #include "clang/Basic/Diagnostic.h"
  11. #include "clang/Basic/Version.h"
  12. #include "clang/Basic/FileManager.h"
  13. #include "clang/Driver/Arg.h"
  14. #include "clang/Driver/ArgList.h"
  15. #include "clang/Driver/CC1Options.h"
  16. #include "clang/Driver/DriverDiagnostic.h"
  17. #include "clang/Driver/OptTable.h"
  18. #include "clang/Driver/Option.h"
  19. #include "clang/Frontend/CompilerInvocation.h"
  20. #include "clang/Frontend/LangStandard.h"
  21. #include "clang/Serialization/ASTReader.h"
  22. #include "llvm/ADT/OwningPtr.h"
  23. #include "llvm/ADT/SmallVector.h"
  24. #include "llvm/ADT/StringExtras.h"
  25. #include "llvm/ADT/StringSwitch.h"
  26. #include "llvm/ADT/Triple.h"
  27. #include "llvm/Support/ErrorHandling.h"
  28. #include "llvm/Support/Host.h"
  29. #include "llvm/Support/Path.h"
  30. using namespace clang;
  31. static const char *getAnalysisStoreName(AnalysisStores Kind) {
  32. switch (Kind) {
  33. default:
  34. llvm_unreachable("Unknown analysis store!");
  35. #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
  36. case NAME##Model: return CMDFLAG;
  37. #include "clang/Frontend/Analyses.def"
  38. }
  39. }
  40. static const char *getAnalysisConstraintName(AnalysisConstraints Kind) {
  41. switch (Kind) {
  42. default:
  43. llvm_unreachable("Unknown analysis constraints!");
  44. #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
  45. case NAME##Model: return CMDFLAG;
  46. #include "clang/Frontend/Analyses.def"
  47. }
  48. }
  49. static const char *getAnalysisDiagClientName(AnalysisDiagClients Kind) {
  50. switch (Kind) {
  51. default:
  52. llvm_unreachable("Unknown analysis client!");
  53. #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREATE) \
  54. case PD_##NAME: return CMDFLAG;
  55. #include "clang/Frontend/Analyses.def"
  56. }
  57. }
  58. static const char *getAnalysisPurgeModeName(AnalysisPurgeMode Kind) {
  59. switch (Kind) {
  60. default:
  61. llvm_unreachable("Unknown analysis client!");
  62. #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
  63. case NAME: return CMDFLAG;
  64. #include "clang/Frontend/Analyses.def"
  65. }
  66. }
  67. //===----------------------------------------------------------------------===//
  68. // Serialization (to args)
  69. //===----------------------------------------------------------------------===//
  70. static void AnalyzerOptsToArgs(const AnalyzerOptions &Opts,
  71. std::vector<std::string> &Res) {
  72. if (Opts.ShowCheckerHelp)
  73. Res.push_back("-analyzer-checker-help");
  74. if (Opts.AnalysisStoreOpt != RegionStoreModel) {
  75. Res.push_back("-analyzer-store");
  76. Res.push_back(getAnalysisStoreName(Opts.AnalysisStoreOpt));
  77. }
  78. if (Opts.AnalysisConstraintsOpt != RangeConstraintsModel) {
  79. Res.push_back("-analyzer-constraints");
  80. Res.push_back(getAnalysisConstraintName(Opts.AnalysisConstraintsOpt));
  81. }
  82. if (Opts.AnalysisDiagOpt != PD_HTML) {
  83. Res.push_back("-analyzer-output");
  84. Res.push_back(getAnalysisDiagClientName(Opts.AnalysisDiagOpt));
  85. }
  86. if (Opts.AnalysisPurgeOpt != PurgeStmt) {
  87. Res.push_back("-analyzer-purge");
  88. Res.push_back(getAnalysisPurgeModeName(Opts.AnalysisPurgeOpt));
  89. }
  90. if (!Opts.AnalyzeSpecificFunction.empty()) {
  91. Res.push_back("-analyze-function");
  92. Res.push_back(Opts.AnalyzeSpecificFunction);
  93. }
  94. if (Opts.AnalyzeAll)
  95. Res.push_back("-analyzer-opt-analyze-headers");
  96. if (Opts.AnalyzerDisplayProgress)
  97. Res.push_back("-analyzer-display-progress");
  98. if (Opts.AnalyzeNestedBlocks)
  99. Res.push_back("-analyzer-opt-analyze-nested-blocks");
  100. if (Opts.EagerlyAssume)
  101. Res.push_back("-analyzer-eagerly-assume");
  102. if (Opts.TrimGraph)
  103. Res.push_back("-trim-egraph");
  104. if (Opts.VisualizeEGDot)
  105. Res.push_back("-analyzer-viz-egraph-graphviz");
  106. if (Opts.VisualizeEGUbi)
  107. Res.push_back("-analyzer-viz-egraph-ubigraph");
  108. for (unsigned i = 0, e = Opts.CheckersControlList.size(); i != e; ++i) {
  109. const std::pair<std::string, bool> &opt = Opts.CheckersControlList[i];
  110. if (opt.second)
  111. Res.push_back("-analyzer-disable-checker");
  112. else
  113. Res.push_back("-analyzer-checker");
  114. Res.push_back(opt.first);
  115. }
  116. }
  117. static void CodeGenOptsToArgs(const CodeGenOptions &Opts,
  118. std::vector<std::string> &Res) {
  119. if (Opts.DebugInfo)
  120. Res.push_back("-g");
  121. if (Opts.DisableLLVMOpts)
  122. Res.push_back("-disable-llvm-optzns");
  123. if (Opts.DisableRedZone)
  124. Res.push_back("-disable-red-zone");
  125. if (!Opts.DwarfDebugFlags.empty()) {
  126. Res.push_back("-dwarf-debug-flags");
  127. Res.push_back(Opts.DwarfDebugFlags);
  128. }
  129. if (Opts.ObjCRuntimeHasARC)
  130. Res.push_back("-fobjc-runtime-has-arc");
  131. if (Opts.ObjCRuntimeHasTerminate)
  132. Res.push_back("-fobjc-runtime-has-terminate");
  133. if (Opts.EmitGcovArcs)
  134. Res.push_back("-femit-coverage-data");
  135. if (Opts.EmitGcovNotes)
  136. Res.push_back("-femit-coverage-notes");
  137. if (!Opts.MergeAllConstants)
  138. Res.push_back("-fno-merge-all-constants");
  139. if (Opts.NoCommon)
  140. Res.push_back("-fno-common");
  141. if (Opts.ForbidGuardVariables)
  142. Res.push_back("-fforbid-guard-variables");
  143. if (Opts.UseRegisterSizedBitfieldAccess)
  144. Res.push_back("-fuse-register-sized-bitfield-access");
  145. if (Opts.NoImplicitFloat)
  146. Res.push_back("-no-implicit-float");
  147. if (Opts.OmitLeafFramePointer)
  148. Res.push_back("-momit-leaf-frame-pointer");
  149. if (Opts.OptimizeSize) {
  150. assert(Opts.OptimizationLevel == 2 && "Invalid options!");
  151. Opts.OptimizeSize == 1 ? Res.push_back("-Os") : Res.push_back("-Oz");
  152. } else if (Opts.OptimizationLevel != 0)
  153. Res.push_back("-O" + llvm::utostr(Opts.OptimizationLevel));
  154. if (!Opts.MainFileName.empty()) {
  155. Res.push_back("-main-file-name");
  156. Res.push_back(Opts.MainFileName);
  157. }
  158. // SimplifyLibCalls is only derived.
  159. // TimePasses is only derived.
  160. // UnitAtATime is unused.
  161. // Inlining is only derived.
  162. // UnrollLoops is derived, but also accepts an option, no
  163. // harm in pushing it back here.
  164. if (Opts.UnrollLoops)
  165. Res.push_back("-funroll-loops");
  166. if (Opts.DataSections)
  167. Res.push_back("-fdata-sections");
  168. if (Opts.FunctionSections)
  169. Res.push_back("-ffunction-sections");
  170. if (Opts.AsmVerbose)
  171. Res.push_back("-masm-verbose");
  172. if (!Opts.CodeModel.empty()) {
  173. Res.push_back("-mcode-model");
  174. Res.push_back(Opts.CodeModel);
  175. }
  176. if (!Opts.CXAAtExit)
  177. Res.push_back("-fno-use-cxa-atexit");
  178. if (Opts.CXXCtorDtorAliases)
  179. Res.push_back("-mconstructor-aliases");
  180. if (Opts.ObjCAutoRefCountExceptions)
  181. Res.push_back("-fobjc-arc-eh");
  182. if (!Opts.DebugPass.empty()) {
  183. Res.push_back("-mdebug-pass");
  184. Res.push_back(Opts.DebugPass);
  185. }
  186. if (Opts.DisableFPElim)
  187. Res.push_back("-mdisable-fp-elim");
  188. if (!Opts.FloatABI.empty()) {
  189. Res.push_back("-mfloat-abi");
  190. Res.push_back(Opts.FloatABI);
  191. }
  192. if (!Opts.LimitFloatPrecision.empty()) {
  193. Res.push_back("-mlimit-float-precision");
  194. Res.push_back(Opts.LimitFloatPrecision);
  195. }
  196. if (Opts.NoZeroInitializedInBSS)
  197. Res.push_back("-mno-zero-initialized-bss");
  198. switch (Opts.getObjCDispatchMethod()) {
  199. case CodeGenOptions::Legacy:
  200. break;
  201. case CodeGenOptions::Mixed:
  202. Res.push_back("-fobjc-dispatch-method=mixed");
  203. break;
  204. case CodeGenOptions::NonLegacy:
  205. Res.push_back("-fobjc-dispatch-method=non-legacy");
  206. break;
  207. }
  208. if (Opts.NumRegisterParameters) {
  209. Res.push_back("-mregparm");
  210. Res.push_back(llvm::utostr(Opts.NumRegisterParameters));
  211. }
  212. if (Opts.NoGlobalMerge)
  213. Res.push_back("-mno-global-merge");
  214. if (Opts.NoExecStack)
  215. Res.push_back("-mnoexecstack");
  216. if (Opts.RelaxAll)
  217. Res.push_back("-mrelax-all");
  218. if (Opts.SaveTempLabels)
  219. Res.push_back("-msave-temp-labels");
  220. if (Opts.NoDwarf2CFIAsm)
  221. Res.push_back("-fno-dwarf2-cfi-asm");
  222. if (Opts.SoftFloat)
  223. Res.push_back("-msoft-float");
  224. if (Opts.UnwindTables)
  225. Res.push_back("-munwind-tables");
  226. if (Opts.RelocationModel != "pic") {
  227. Res.push_back("-mrelocation-model");
  228. Res.push_back(Opts.RelocationModel);
  229. }
  230. if (!Opts.VerifyModule)
  231. Res.push_back("-disable-llvm-verifier");
  232. for (unsigned i = 0, e = Opts.BackendOptions.size(); i != e; ++i) {
  233. Res.push_back("-backend-option");
  234. Res.push_back(Opts.BackendOptions[i]);
  235. }
  236. }
  237. static void DependencyOutputOptsToArgs(const DependencyOutputOptions &Opts,
  238. std::vector<std::string> &Res) {
  239. if (Opts.IncludeSystemHeaders)
  240. Res.push_back("-sys-header-deps");
  241. if (Opts.ShowHeaderIncludes)
  242. Res.push_back("-H");
  243. if (!Opts.HeaderIncludeOutputFile.empty()) {
  244. Res.push_back("-header-include-file");
  245. Res.push_back(Opts.HeaderIncludeOutputFile);
  246. }
  247. if (Opts.UsePhonyTargets)
  248. Res.push_back("-MP");
  249. if (!Opts.OutputFile.empty()) {
  250. Res.push_back("-dependency-file");
  251. Res.push_back(Opts.OutputFile);
  252. }
  253. for (unsigned i = 0, e = Opts.Targets.size(); i != e; ++i) {
  254. Res.push_back("-MT");
  255. Res.push_back(Opts.Targets[i]);
  256. }
  257. }
  258. static void DiagnosticOptsToArgs(const DiagnosticOptions &Opts,
  259. std::vector<std::string> &Res) {
  260. if (Opts.IgnoreWarnings)
  261. Res.push_back("-w");
  262. if (Opts.NoRewriteMacros)
  263. Res.push_back("-Wno-rewrite-macros");
  264. if (Opts.Pedantic)
  265. Res.push_back("-pedantic");
  266. if (Opts.PedanticErrors)
  267. Res.push_back("-pedantic-errors");
  268. if (!Opts.ShowColumn)
  269. Res.push_back("-fno-show-column");
  270. if (!Opts.ShowLocation)
  271. Res.push_back("-fno-show-source-location");
  272. if (!Opts.ShowCarets)
  273. Res.push_back("-fno-caret-diagnostics");
  274. if (!Opts.ShowFixits)
  275. Res.push_back("-fno-diagnostics-fixit-info");
  276. if (Opts.ShowSourceRanges)
  277. Res.push_back("-fdiagnostics-print-source-range-info");
  278. if (Opts.ShowParseableFixits)
  279. Res.push_back("-fdiagnostics-parseable-fixits");
  280. if (Opts.ShowColors)
  281. Res.push_back("-fcolor-diagnostics");
  282. if (Opts.VerifyDiagnostics)
  283. Res.push_back("-verify");
  284. if (Opts.ShowNames)
  285. Res.push_back("-fdiagnostics-show-name");
  286. if (Opts.ShowOptionNames)
  287. Res.push_back("-fdiagnostics-show-option");
  288. if (Opts.ShowCategories == 1)
  289. Res.push_back("-fdiagnostics-show-category=id");
  290. else if (Opts.ShowCategories == 2)
  291. Res.push_back("-fdiagnostics-show-category=name");
  292. switch (Opts.Format) {
  293. case DiagnosticOptions::Clang:
  294. Res.push_back("-fdiagnostics-format=clang"); break;
  295. case DiagnosticOptions::Msvc:
  296. Res.push_back("-fdiagnostics-format=msvc"); break;
  297. case DiagnosticOptions::Vi:
  298. Res.push_back("-fdiagnostics-format=vi"); break;
  299. }
  300. if (Opts.ErrorLimit) {
  301. Res.push_back("-ferror-limit");
  302. Res.push_back(llvm::utostr(Opts.ErrorLimit));
  303. }
  304. if (!Opts.DiagnosticLogFile.empty()) {
  305. Res.push_back("-diagnostic-log-file");
  306. Res.push_back(Opts.DiagnosticLogFile);
  307. }
  308. if (Opts.MacroBacktraceLimit
  309. != DiagnosticOptions::DefaultMacroBacktraceLimit) {
  310. Res.push_back("-fmacro-backtrace-limit");
  311. Res.push_back(llvm::utostr(Opts.MacroBacktraceLimit));
  312. }
  313. if (Opts.TemplateBacktraceLimit
  314. != DiagnosticOptions::DefaultTemplateBacktraceLimit) {
  315. Res.push_back("-ftemplate-backtrace-limit");
  316. Res.push_back(llvm::utostr(Opts.TemplateBacktraceLimit));
  317. }
  318. if (Opts.TabStop != DiagnosticOptions::DefaultTabStop) {
  319. Res.push_back("-ftabstop");
  320. Res.push_back(llvm::utostr(Opts.TabStop));
  321. }
  322. if (Opts.MessageLength) {
  323. Res.push_back("-fmessage-length");
  324. Res.push_back(llvm::utostr(Opts.MessageLength));
  325. }
  326. if (!Opts.DumpBuildInformation.empty()) {
  327. Res.push_back("-dump-build-information");
  328. Res.push_back(Opts.DumpBuildInformation);
  329. }
  330. for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i)
  331. Res.push_back("-W" + Opts.Warnings[i]);
  332. }
  333. static const char *getInputKindName(InputKind Kind) {
  334. switch (Kind) {
  335. case IK_None: break;
  336. case IK_AST: return "ast";
  337. case IK_Asm: return "assembler-with-cpp";
  338. case IK_C: return "c";
  339. case IK_CXX: return "c++";
  340. case IK_LLVM_IR: return "ir";
  341. case IK_ObjC: return "objective-c";
  342. case IK_ObjCXX: return "objective-c++";
  343. case IK_OpenCL: return "cl";
  344. case IK_CUDA: return "cuda";
  345. case IK_PreprocessedC: return "cpp-output";
  346. case IK_PreprocessedCXX: return "c++-cpp-output";
  347. case IK_PreprocessedObjC: return "objective-c-cpp-output";
  348. case IK_PreprocessedObjCXX:return "objective-c++-cpp-output";
  349. }
  350. llvm_unreachable("Unexpected language kind!");
  351. return 0;
  352. }
  353. static const char *getActionName(frontend::ActionKind Kind) {
  354. switch (Kind) {
  355. case frontend::PluginAction:
  356. llvm_unreachable("Invalid kind!");
  357. case frontend::ASTDump: return "-ast-dump";
  358. case frontend::ASTDumpXML: return "-ast-dump-xml";
  359. case frontend::ASTPrint: return "-ast-print";
  360. case frontend::ASTView: return "-ast-view";
  361. case frontend::DumpRawTokens: return "-dump-raw-tokens";
  362. case frontend::DumpTokens: return "-dump-tokens";
  363. case frontend::EmitAssembly: return "-S";
  364. case frontend::EmitBC: return "-emit-llvm-bc";
  365. case frontend::EmitHTML: return "-emit-html";
  366. case frontend::EmitLLVM: return "-emit-llvm";
  367. case frontend::EmitLLVMOnly: return "-emit-llvm-only";
  368. case frontend::EmitCodeGenOnly: return "-emit-codegen-only";
  369. case frontend::EmitObj: return "-emit-obj";
  370. case frontend::FixIt: return "-fixit";
  371. case frontend::GenerateModule: return "-emit-module";
  372. case frontend::GeneratePCH: return "-emit-pch";
  373. case frontend::GeneratePTH: return "-emit-pth";
  374. case frontend::InitOnly: return "-init-only";
  375. case frontend::ParseSyntaxOnly: return "-fsyntax-only";
  376. case frontend::PrintDeclContext: return "-print-decl-contexts";
  377. case frontend::PrintPreamble: return "-print-preamble";
  378. case frontend::PrintPreprocessedInput: return "-E";
  379. case frontend::RewriteMacros: return "-rewrite-macros";
  380. case frontend::RewriteObjC: return "-rewrite-objc";
  381. case frontend::RewriteTest: return "-rewrite-test";
  382. case frontend::RunAnalysis: return "-analyze";
  383. case frontend::RunPreprocessorOnly: return "-Eonly";
  384. }
  385. llvm_unreachable("Unexpected language kind!");
  386. return 0;
  387. }
  388. static void FileSystemOptsToArgs(const FileSystemOptions &Opts,
  389. std::vector<std::string> &Res) {
  390. if (!Opts.WorkingDir.empty()) {
  391. Res.push_back("-working-directory");
  392. Res.push_back(Opts.WorkingDir);
  393. }
  394. }
  395. static void FrontendOptsToArgs(const FrontendOptions &Opts,
  396. std::vector<std::string> &Res) {
  397. if (Opts.DisableFree)
  398. Res.push_back("-disable-free");
  399. if (Opts.RelocatablePCH)
  400. Res.push_back("-relocatable-pch");
  401. if (Opts.ShowHelp)
  402. Res.push_back("-help");
  403. if (Opts.ShowMacrosInCodeCompletion)
  404. Res.push_back("-code-completion-macros");
  405. if (Opts.ShowCodePatternsInCodeCompletion)
  406. Res.push_back("-code-completion-patterns");
  407. if (!Opts.ShowGlobalSymbolsInCodeCompletion)
  408. Res.push_back("-no-code-completion-globals");
  409. if (Opts.ShowStats)
  410. Res.push_back("-print-stats");
  411. if (Opts.ShowTimers)
  412. Res.push_back("-ftime-report");
  413. if (Opts.ShowVersion)
  414. Res.push_back("-version");
  415. if (Opts.FixWhatYouCan)
  416. Res.push_back("-fix-what-you-can");
  417. switch (Opts.ARCMTAction) {
  418. case FrontendOptions::ARCMT_None:
  419. break;
  420. case FrontendOptions::ARCMT_Check:
  421. Res.push_back("-arcmt-check");
  422. break;
  423. case FrontendOptions::ARCMT_Modify:
  424. Res.push_back("-arcmt-modify");
  425. break;
  426. case FrontendOptions::ARCMT_Migrate:
  427. Res.push_back("-arcmt-migrate");
  428. break;
  429. }
  430. if (!Opts.ARCMTMigrateDir.empty()) {
  431. Res.push_back("-arcmt-migrate-directory");
  432. Res.push_back(Opts.ARCMTMigrateDir);
  433. }
  434. if (!Opts.ARCMTMigrateReportOut.empty()) {
  435. Res.push_back("-arcmt-migrate-report-output");
  436. Res.push_back(Opts.ARCMTMigrateReportOut);
  437. }
  438. if (Opts.ARCMTMigrateEmitARCErrors)
  439. Res.push_back("-arcmt-migrate-emit-errors");
  440. bool NeedLang = false;
  441. for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i)
  442. if (FrontendOptions::getInputKindForExtension(Opts.Inputs[i].second) !=
  443. Opts.Inputs[i].first)
  444. NeedLang = true;
  445. if (NeedLang) {
  446. Res.push_back("-x");
  447. Res.push_back(getInputKindName(Opts.Inputs[0].first));
  448. }
  449. for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i) {
  450. assert((!NeedLang || Opts.Inputs[i].first == Opts.Inputs[0].first) &&
  451. "Unable to represent this input vector!");
  452. Res.push_back(Opts.Inputs[i].second);
  453. }
  454. if (!Opts.OutputFile.empty()) {
  455. Res.push_back("-o");
  456. Res.push_back(Opts.OutputFile);
  457. }
  458. if (!Opts.CodeCompletionAt.FileName.empty()) {
  459. Res.push_back("-code-completion-at");
  460. Res.push_back(Opts.CodeCompletionAt.FileName + ":" +
  461. llvm::utostr(Opts.CodeCompletionAt.Line) + ":" +
  462. llvm::utostr(Opts.CodeCompletionAt.Column));
  463. }
  464. if (Opts.ProgramAction != frontend::PluginAction)
  465. Res.push_back(getActionName(Opts.ProgramAction));
  466. if (!Opts.ActionName.empty()) {
  467. Res.push_back("-plugin");
  468. Res.push_back(Opts.ActionName);
  469. for(unsigned i = 0, e = Opts.PluginArgs.size(); i != e; ++i) {
  470. Res.push_back("-plugin-arg-" + Opts.ActionName);
  471. Res.push_back(Opts.PluginArgs[i]);
  472. }
  473. }
  474. for (unsigned i = 0, e = Opts.Plugins.size(); i != e; ++i) {
  475. Res.push_back("-load");
  476. Res.push_back(Opts.Plugins[i]);
  477. }
  478. for (unsigned i = 0, e = Opts.AddPluginActions.size(); i != e; ++i) {
  479. Res.push_back("-add-plugin");
  480. Res.push_back(Opts.AddPluginActions[i]);
  481. for(unsigned ai = 0, ae = Opts.AddPluginArgs.size(); ai != ae; ++ai) {
  482. Res.push_back("-plugin-arg-" + Opts.AddPluginActions[i]);
  483. Res.push_back(Opts.AddPluginArgs[i][ai]);
  484. }
  485. }
  486. for (unsigned i = 0, e = Opts.ASTMergeFiles.size(); i != e; ++i) {
  487. Res.push_back("-ast-merge");
  488. Res.push_back(Opts.ASTMergeFiles[i]);
  489. }
  490. for (unsigned i = 0, e = Opts.LLVMArgs.size(); i != e; ++i) {
  491. Res.push_back("-mllvm");
  492. Res.push_back(Opts.LLVMArgs[i]);
  493. }
  494. }
  495. static void HeaderSearchOptsToArgs(const HeaderSearchOptions &Opts,
  496. std::vector<std::string> &Res) {
  497. if (Opts.Sysroot != "/") {
  498. Res.push_back("-isysroot");
  499. Res.push_back(Opts.Sysroot);
  500. }
  501. /// User specified include entries.
  502. for (unsigned i = 0, e = Opts.UserEntries.size(); i != e; ++i) {
  503. const HeaderSearchOptions::Entry &E = Opts.UserEntries[i];
  504. if (E.IsFramework && (E.Group != frontend::Angled || !E.IsUserSupplied))
  505. llvm::report_fatal_error("Invalid option set!");
  506. if (E.IsUserSupplied) {
  507. switch (E.Group) {
  508. case frontend::After:
  509. Res.push_back("-idirafter");
  510. break;
  511. case frontend::Quoted:
  512. Res.push_back("-iquote");
  513. break;
  514. case frontend::System:
  515. Res.push_back("-isystem");
  516. break;
  517. case frontend::IndexHeaderMap:
  518. Res.push_back("-index-header-map");
  519. Res.push_back(E.IsFramework? "-F" : "-I");
  520. break;
  521. case frontend::CSystem:
  522. Res.push_back("-c-isystem");
  523. break;
  524. case frontend::CXXSystem:
  525. Res.push_back("-cxx-isystem");
  526. break;
  527. case frontend::ObjCSystem:
  528. Res.push_back("-objc-isystem");
  529. break;
  530. case frontend::ObjCXXSystem:
  531. Res.push_back("-objcxx-isystem");
  532. break;
  533. case frontend::Angled:
  534. Res.push_back(E.IsFramework ? "-F" : "-I");
  535. break;
  536. }
  537. } else {
  538. if (E.Group != frontend::Angled && E.Group != frontend::System)
  539. llvm::report_fatal_error("Invalid option set!");
  540. Res.push_back(E.Group == frontend::Angled ? "-iwithprefixbefore" :
  541. "-iwithprefix");
  542. }
  543. Res.push_back(E.Path);
  544. }
  545. if (!Opts.ResourceDir.empty()) {
  546. Res.push_back("-resource-dir");
  547. Res.push_back(Opts.ResourceDir);
  548. }
  549. if (!Opts.ModuleCachePath.empty()) {
  550. Res.push_back("-fmodule-cache-path");
  551. Res.push_back(Opts.ModuleCachePath);
  552. }
  553. if (!Opts.UseStandardIncludes)
  554. Res.push_back("-nostdinc");
  555. if (!Opts.UseStandardCXXIncludes)
  556. Res.push_back("-nostdinc++");
  557. if (Opts.UseLibcxx)
  558. Res.push_back("-stdlib=libc++");
  559. if (Opts.Verbose)
  560. Res.push_back("-v");
  561. }
  562. static void LangOptsToArgs(const LangOptions &Opts,
  563. std::vector<std::string> &Res) {
  564. LangOptions DefaultLangOpts;
  565. // FIXME: Need to set -std to get all the implicit options.
  566. // FIXME: We want to only pass options relative to the defaults, which
  567. // requires constructing a target. :(
  568. //
  569. // It would be better to push the all target specific choices into the driver,
  570. // so that everything below that was more uniform.
  571. if (Opts.Trigraphs)
  572. Res.push_back("-trigraphs");
  573. // Implicit based on the input kind:
  574. // AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL
  575. // Implicit based on the input language standard:
  576. // BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode
  577. if (Opts.DollarIdents)
  578. Res.push_back("-fdollars-in-identifiers");
  579. if (Opts.GNUMode && !Opts.GNUKeywords)
  580. Res.push_back("-fno-gnu-keywords");
  581. if (!Opts.GNUMode && Opts.GNUKeywords)
  582. Res.push_back("-fgnu-keywords");
  583. if (Opts.MicrosoftExt)
  584. Res.push_back("-fms-extensions");
  585. if (Opts.MSCVersion != 0)
  586. Res.push_back("-fmsc-version=" + llvm::utostr(Opts.MSCVersion));
  587. if (Opts.Borland)
  588. Res.push_back("-fborland-extensions");
  589. if (!Opts.ObjCNonFragileABI)
  590. Res.push_back("-fobjc-fragile-abi");
  591. if (Opts.ObjCDefaultSynthProperties)
  592. Res.push_back("-fobjc-default-synthesize-properties");
  593. // NoInline is implicit.
  594. if (!Opts.CXXOperatorNames)
  595. Res.push_back("-fno-operator-names");
  596. if (Opts.PascalStrings)
  597. Res.push_back("-fpascal-strings");
  598. if (Opts.CatchUndefined)
  599. Res.push_back("-fcatch-undefined-behavior");
  600. if (Opts.WritableStrings)
  601. Res.push_back("-fwritable-strings");
  602. if (Opts.ConstStrings)
  603. Res.push_back("-fconst-strings");
  604. if (!Opts.LaxVectorConversions)
  605. Res.push_back("-fno-lax-vector-conversions");
  606. if (Opts.AltiVec)
  607. Res.push_back("-faltivec");
  608. if (Opts.Exceptions)
  609. Res.push_back("-fexceptions");
  610. if (Opts.ObjCExceptions)
  611. Res.push_back("-fobjc-exceptions");
  612. if (Opts.CXXExceptions)
  613. Res.push_back("-fcxx-exceptions");
  614. if (Opts.SjLjExceptions)
  615. Res.push_back("-fsjlj-exceptions");
  616. if (Opts.TraditionalCPP)
  617. Res.push_back("-traditional-cpp");
  618. if (!Opts.RTTI)
  619. Res.push_back("-fno-rtti");
  620. if (Opts.MSBitfields)
  621. Res.push_back("-mms-bitfields");
  622. if (!Opts.NeXTRuntime)
  623. Res.push_back("-fgnu-runtime");
  624. if (Opts.Freestanding)
  625. Res.push_back("-ffreestanding");
  626. if (Opts.NoBuiltin)
  627. Res.push_back("-fno-builtin");
  628. if (!Opts.AssumeSaneOperatorNew)
  629. Res.push_back("-fno-assume-sane-operator-new");
  630. if (!Opts.ThreadsafeStatics)
  631. Res.push_back("-fno-threadsafe-statics");
  632. if (Opts.POSIXThreads)
  633. Res.push_back("-pthread");
  634. if (Opts.Blocks)
  635. Res.push_back("-fblocks");
  636. if (Opts.BlocksRuntimeOptional)
  637. Res.push_back("-fblocks-runtime-optional");
  638. if (Opts.EmitAllDecls)
  639. Res.push_back("-femit-all-decls");
  640. if (Opts.MathErrno)
  641. Res.push_back("-fmath-errno");
  642. switch (Opts.getSignedOverflowBehavior()) {
  643. case LangOptions::SOB_Undefined: break;
  644. case LangOptions::SOB_Defined: Res.push_back("-fwrapv"); break;
  645. case LangOptions::SOB_Trapping:
  646. Res.push_back("-ftrapv"); break;
  647. if (!Opts.OverflowHandler.empty()) {
  648. Res.push_back("-ftrapv-handler");
  649. Res.push_back(Opts.OverflowHandler);
  650. }
  651. }
  652. if (Opts.HeinousExtensions)
  653. Res.push_back("-fheinous-gnu-extensions");
  654. // Optimize is implicit.
  655. // OptimizeSize is implicit.
  656. if (Opts.Static)
  657. Res.push_back("-static-define");
  658. if (Opts.DumpRecordLayouts)
  659. Res.push_back("-fdump-record-layouts");
  660. if (Opts.DumpVTableLayouts)
  661. Res.push_back("-fdump-vtable-layouts");
  662. if (Opts.NoBitFieldTypeAlign)
  663. Res.push_back("-fno-bitfield-type-alignment");
  664. if (Opts.PICLevel) {
  665. Res.push_back("-pic-level");
  666. Res.push_back(llvm::utostr(Opts.PICLevel));
  667. }
  668. if (Opts.ObjCGCBitmapPrint)
  669. Res.push_back("-print-ivar-layout");
  670. if (Opts.NoConstantCFStrings)
  671. Res.push_back("-fno-constant-cfstrings");
  672. if (!Opts.AccessControl)
  673. Res.push_back("-fno-access-control");
  674. if (!Opts.CharIsSigned)
  675. Res.push_back("-fno-signed-char");
  676. if (Opts.ShortWChar)
  677. Res.push_back("-fshort-wchar");
  678. if (!Opts.ElideConstructors)
  679. Res.push_back("-fno-elide-constructors");
  680. if (Opts.getGC() != LangOptions::NonGC) {
  681. if (Opts.getGC() == LangOptions::HybridGC) {
  682. Res.push_back("-fobjc-gc");
  683. } else {
  684. assert(Opts.getGC() == LangOptions::GCOnly && "Invalid GC mode!");
  685. Res.push_back("-fobjc-gc-only");
  686. }
  687. }
  688. if (Opts.ObjCAutoRefCount)
  689. Res.push_back("-fobjc-arc");
  690. if (Opts.ObjCRuntimeHasWeak)
  691. Res.push_back("-fobjc-runtime-has-weak");
  692. if (!Opts.ObjCInferRelatedResultType)
  693. Res.push_back("-fno-objc-infer-related-result-type");
  694. if (Opts.AppleKext)
  695. Res.push_back("-fapple-kext");
  696. if (Opts.getVisibilityMode() != DefaultVisibility) {
  697. Res.push_back("-fvisibility");
  698. if (Opts.getVisibilityMode() == HiddenVisibility) {
  699. Res.push_back("hidden");
  700. } else {
  701. assert(Opts.getVisibilityMode() == ProtectedVisibility &&
  702. "Invalid visibility!");
  703. Res.push_back("protected");
  704. }
  705. }
  706. if (Opts.InlineVisibilityHidden)
  707. Res.push_back("-fvisibility-inlines-hidden");
  708. if (Opts.getStackProtector() != 0) {
  709. Res.push_back("-stack-protector");
  710. Res.push_back(llvm::utostr(Opts.getStackProtector()));
  711. }
  712. if (Opts.InstantiationDepth != DefaultLangOpts.InstantiationDepth) {
  713. Res.push_back("-ftemplate-depth");
  714. Res.push_back(llvm::utostr(Opts.InstantiationDepth));
  715. }
  716. if (!Opts.ObjCConstantStringClass.empty()) {
  717. Res.push_back("-fconstant-string-class");
  718. Res.push_back(Opts.ObjCConstantStringClass);
  719. }
  720. if (Opts.FakeAddressSpaceMap)
  721. Res.push_back("-ffake-address-space-map");
  722. if (Opts.ParseUnknownAnytype)
  723. Res.push_back("-funknown-anytype");
  724. if (Opts.DebuggerSupport)
  725. Res.push_back("-fdebugger-support");
  726. if (Opts.DelayedTemplateParsing)
  727. Res.push_back("-fdelayed-template-parsing");
  728. if (Opts.Deprecated)
  729. Res.push_back("-fdeprecated-macro");
  730. }
  731. static void PreprocessorOptsToArgs(const PreprocessorOptions &Opts,
  732. std::vector<std::string> &Res) {
  733. for (unsigned i = 0, e = Opts.Macros.size(); i != e; ++i)
  734. Res.push_back(std::string(Opts.Macros[i].second ? "-U" : "-D") +
  735. Opts.Macros[i].first);
  736. for (unsigned i = 0, e = Opts.Includes.size(); i != e; ++i) {
  737. // FIXME: We need to avoid reincluding the implicit PCH and PTH includes.
  738. Res.push_back("-include");
  739. Res.push_back(Opts.Includes[i]);
  740. }
  741. for (unsigned i = 0, e = Opts.MacroIncludes.size(); i != e; ++i) {
  742. Res.push_back("-imacros");
  743. Res.push_back(Opts.MacroIncludes[i]);
  744. }
  745. if (!Opts.UsePredefines)
  746. Res.push_back("-undef");
  747. if (Opts.DetailedRecord)
  748. Res.push_back("-detailed-preprocessing-record");
  749. if (!Opts.ImplicitPCHInclude.empty()) {
  750. Res.push_back("-include-pch");
  751. Res.push_back(Opts.ImplicitPCHInclude);
  752. }
  753. if (!Opts.ImplicitPTHInclude.empty()) {
  754. Res.push_back("-include-pth");
  755. Res.push_back(Opts.ImplicitPTHInclude);
  756. }
  757. if (!Opts.TokenCache.empty()) {
  758. if (Opts.ImplicitPTHInclude.empty()) {
  759. Res.push_back("-token-cache");
  760. Res.push_back(Opts.TokenCache);
  761. } else
  762. assert(Opts.ImplicitPTHInclude == Opts.TokenCache &&
  763. "Unsupported option combination!");
  764. }
  765. for (unsigned i = 0, e = Opts.ChainedIncludes.size(); i != e; ++i) {
  766. Res.push_back("-chain-include");
  767. Res.push_back(Opts.ChainedIncludes[i]);
  768. }
  769. for (unsigned i = 0, e = Opts.RemappedFiles.size(); i != e; ++i) {
  770. Res.push_back("-remap-file");
  771. Res.push_back(Opts.RemappedFiles[i].first + ";" +
  772. Opts.RemappedFiles[i].second);
  773. }
  774. }
  775. static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions &Opts,
  776. std::vector<std::string> &Res) {
  777. if (!Opts.ShowCPP && !Opts.ShowMacros)
  778. llvm::report_fatal_error("Invalid option combination!");
  779. if (Opts.ShowCPP && Opts.ShowMacros)
  780. Res.push_back("-dD");
  781. else if (!Opts.ShowCPP && Opts.ShowMacros)
  782. Res.push_back("-dM");
  783. if (!Opts.ShowLineMarkers)
  784. Res.push_back("-P");
  785. if (Opts.ShowComments)
  786. Res.push_back("-C");
  787. if (Opts.ShowMacroComments)
  788. Res.push_back("-CC");
  789. }
  790. static void TargetOptsToArgs(const TargetOptions &Opts,
  791. std::vector<std::string> &Res) {
  792. Res.push_back("-triple");
  793. Res.push_back(Opts.Triple);
  794. if (!Opts.CPU.empty()) {
  795. Res.push_back("-target-cpu");
  796. Res.push_back(Opts.CPU);
  797. }
  798. if (!Opts.ABI.empty()) {
  799. Res.push_back("-target-abi");
  800. Res.push_back(Opts.ABI);
  801. }
  802. if (!Opts.LinkerVersion.empty()) {
  803. Res.push_back("-target-linker-version");
  804. Res.push_back(Opts.LinkerVersion);
  805. }
  806. if (!Opts.CXXABI.empty()) {
  807. Res.push_back("-cxx-abi");
  808. Res.push_back(Opts.CXXABI);
  809. }
  810. for (unsigned i = 0, e = Opts.Features.size(); i != e; ++i) {
  811. Res.push_back("-target-feature");
  812. Res.push_back(Opts.Features[i]);
  813. }
  814. }
  815. void CompilerInvocation::toArgs(std::vector<std::string> &Res) {
  816. AnalyzerOptsToArgs(getAnalyzerOpts(), Res);
  817. CodeGenOptsToArgs(getCodeGenOpts(), Res);
  818. DependencyOutputOptsToArgs(getDependencyOutputOpts(), Res);
  819. DiagnosticOptsToArgs(getDiagnosticOpts(), Res);
  820. FileSystemOptsToArgs(getFileSystemOpts(), Res);
  821. FrontendOptsToArgs(getFrontendOpts(), Res);
  822. HeaderSearchOptsToArgs(getHeaderSearchOpts(), Res);
  823. LangOptsToArgs(getLangOpts(), Res);
  824. PreprocessorOptsToArgs(getPreprocessorOpts(), Res);
  825. PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), Res);
  826. TargetOptsToArgs(getTargetOpts(), Res);
  827. }
  828. //===----------------------------------------------------------------------===//
  829. // Deserialization (to args)
  830. //===----------------------------------------------------------------------===//
  831. using namespace clang::driver;
  832. using namespace clang::driver::cc1options;
  833. //
  834. static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
  835. DiagnosticsEngine &Diags) {
  836. unsigned DefaultOpt = 0;
  837. if (IK == IK_OpenCL && !Args.hasArg(OPT_cl_opt_disable))
  838. DefaultOpt = 2;
  839. // -Os/-Oz implies -O2
  840. return (Args.hasArg(OPT_Os) || Args.hasArg (OPT_Oz)) ? 2 :
  841. Args.getLastArgIntValue(OPT_O, DefaultOpt, Diags);
  842. }
  843. static void ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
  844. DiagnosticsEngine &Diags) {
  845. using namespace cc1options;
  846. if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
  847. StringRef Name = A->getValue(Args);
  848. AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name)
  849. #define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \
  850. .Case(CMDFLAG, NAME##Model)
  851. #include "clang/Frontend/Analyses.def"
  852. .Default(NumStores);
  853. // FIXME: Error handling.
  854. if (Value == NumStores)
  855. Diags.Report(diag::err_drv_invalid_value)
  856. << A->getAsString(Args) << Name;
  857. else
  858. Opts.AnalysisStoreOpt = Value;
  859. }
  860. if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) {
  861. StringRef Name = A->getValue(Args);
  862. AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name)
  863. #define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \
  864. .Case(CMDFLAG, NAME##Model)
  865. #include "clang/Frontend/Analyses.def"
  866. .Default(NumConstraints);
  867. // FIXME: Error handling.
  868. if (Value == NumConstraints)
  869. Diags.Report(diag::err_drv_invalid_value)
  870. << A->getAsString(Args) << Name;
  871. else
  872. Opts.AnalysisConstraintsOpt = Value;
  873. }
  874. if (Arg *A = Args.getLastArg(OPT_analyzer_output)) {
  875. StringRef Name = A->getValue(Args);
  876. AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name)
  877. #define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) \
  878. .Case(CMDFLAG, PD_##NAME)
  879. #include "clang/Frontend/Analyses.def"
  880. .Default(NUM_ANALYSIS_DIAG_CLIENTS);
  881. // FIXME: Error handling.
  882. if (Value == NUM_ANALYSIS_DIAG_CLIENTS)
  883. Diags.Report(diag::err_drv_invalid_value)
  884. << A->getAsString(Args) << Name;
  885. else
  886. Opts.AnalysisDiagOpt = Value;
  887. }
  888. if (Arg *A = Args.getLastArg(OPT_analyzer_purge)) {
  889. StringRef Name = A->getValue(Args);
  890. AnalysisPurgeMode Value = llvm::StringSwitch<AnalysisPurgeMode>(Name)
  891. #define ANALYSIS_PURGE(NAME, CMDFLAG, DESC) \
  892. .Case(CMDFLAG, NAME)
  893. #include "clang/Frontend/Analyses.def"
  894. .Default(NumPurgeModes);
  895. // FIXME: Error handling.
  896. if (Value == NumPurgeModes)
  897. Diags.Report(diag::err_drv_invalid_value)
  898. << A->getAsString(Args) << Name;
  899. else
  900. Opts.AnalysisPurgeOpt = Value;
  901. }
  902. Opts.ShowCheckerHelp = Args.hasArg(OPT_analyzer_checker_help);
  903. Opts.VisualizeEGDot = Args.hasArg(OPT_analyzer_viz_egraph_graphviz);
  904. Opts.VisualizeEGUbi = Args.hasArg(OPT_analyzer_viz_egraph_ubigraph);
  905. Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers);
  906. Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress);
  907. Opts.AnalyzeNestedBlocks =
  908. Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks);
  909. Opts.EagerlyAssume = Args.hasArg(OPT_analyzer_eagerly_assume);
  910. Opts.AnalyzeSpecificFunction = Args.getLastArgValue(OPT_analyze_function);
  911. Opts.UnoptimizedCFG = Args.hasArg(OPT_analysis_UnoptimizedCFG);
  912. Opts.CFGAddImplicitDtors = Args.hasArg(OPT_analysis_CFGAddImplicitDtors);
  913. Opts.CFGAddInitializers = Args.hasArg(OPT_analysis_CFGAddInitializers);
  914. Opts.TrimGraph = Args.hasArg(OPT_trim_egraph);
  915. Opts.MaxNodes = Args.getLastArgIntValue(OPT_analyzer_max_nodes, 150000,Diags);
  916. Opts.MaxLoop = Args.getLastArgIntValue(OPT_analyzer_max_loop, 4, Diags);
  917. Opts.EagerlyTrimEGraph = !Args.hasArg(OPT_analyzer_no_eagerly_trim_egraph);
  918. Opts.InlineCall = Args.hasArg(OPT_analyzer_inline_call);
  919. Opts.CheckersControlList.clear();
  920. for (arg_iterator it = Args.filtered_begin(OPT_analyzer_checker,
  921. OPT_analyzer_disable_checker),
  922. ie = Args.filtered_end(); it != ie; ++it) {
  923. const Arg *A = *it;
  924. A->claim();
  925. bool enable = (A->getOption().getID() == OPT_analyzer_checker);
  926. // We can have a list of comma separated checker names, e.g:
  927. // '-analyzer-checker=cocoa,unix'
  928. StringRef checkerList = A->getValue(Args);
  929. SmallVector<StringRef, 4> checkers;
  930. checkerList.split(checkers, ",");
  931. for (unsigned i = 0, e = checkers.size(); i != e; ++i)
  932. Opts.CheckersControlList.push_back(std::make_pair(checkers[i], enable));
  933. }
  934. }
  935. static void ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, InputKind IK,
  936. DiagnosticsEngine &Diags) {
  937. using namespace cc1options;
  938. Opts.OptimizationLevel = getOptimizationLevel(Args, IK, Diags);
  939. if (Opts.OptimizationLevel > 3) {
  940. Diags.Report(diag::err_drv_invalid_value)
  941. << Args.getLastArg(OPT_O)->getAsString(Args) << Opts.OptimizationLevel;
  942. Opts.OptimizationLevel = 3;
  943. }
  944. // We must always run at least the always inlining pass.
  945. Opts.Inlining = (Opts.OptimizationLevel > 1) ? CodeGenOptions::NormalInlining
  946. : CodeGenOptions::OnlyAlwaysInlining;
  947. Opts.DebugInfo = Args.hasArg(OPT_g);
  948. Opts.LimitDebugInfo = Args.hasArg(OPT_flimit_debug_info);
  949. Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns);
  950. Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone);
  951. Opts.ForbidGuardVariables = Args.hasArg(OPT_fforbid_guard_variables);
  952. Opts.UseRegisterSizedBitfieldAccess = Args.hasArg(
  953. OPT_fuse_register_sized_bitfield_access);
  954. Opts.RelaxedAliasing = Args.hasArg(OPT_relaxed_aliasing);
  955. Opts.DwarfDebugFlags = Args.getLastArgValue(OPT_dwarf_debug_flags);
  956. Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants);
  957. Opts.NoCommon = Args.hasArg(OPT_fno_common);
  958. Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float);
  959. Opts.OptimizeSize = Args.hasArg(OPT_Os);
  960. Opts.OptimizeSize = Args.hasArg(OPT_Oz) ? 2 : Opts.OptimizeSize;
  961. Opts.SimplifyLibCalls = !(Args.hasArg(OPT_fno_builtin) ||
  962. Args.hasArg(OPT_ffreestanding));
  963. Opts.UnrollLoops = Args.hasArg(OPT_funroll_loops) ||
  964. (Opts.OptimizationLevel > 1 && !Opts.OptimizeSize);
  965. Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose);
  966. Opts.ObjCAutoRefCountExceptions = Args.hasArg(OPT_fobjc_arc_exceptions);
  967. Opts.ObjCRuntimeHasARC = Args.hasArg(OPT_fobjc_runtime_has_arc);
  968. Opts.ObjCRuntimeHasTerminate = Args.hasArg(OPT_fobjc_runtime_has_terminate);
  969. Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit);
  970. Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases);
  971. Opts.CodeModel = Args.getLastArgValue(OPT_mcode_model);
  972. Opts.DebugPass = Args.getLastArgValue(OPT_mdebug_pass);
  973. Opts.DisableFPElim = Args.hasArg(OPT_mdisable_fp_elim);
  974. Opts.FloatABI = Args.getLastArgValue(OPT_mfloat_abi);
  975. Opts.HiddenWeakVTables = Args.hasArg(OPT_fhidden_weak_vtables);
  976. Opts.LessPreciseFPMAD = Args.hasArg(OPT_cl_mad_enable);
  977. Opts.LimitFloatPrecision = Args.getLastArgValue(OPT_mlimit_float_precision);
  978. Opts.NoInfsFPMath = Opts.NoNaNsFPMath = Args.hasArg(OPT_cl_finite_math_only)||
  979. Args.hasArg(OPT_cl_fast_relaxed_math);
  980. Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss);
  981. Opts.BackendOptions = Args.getAllArgValues(OPT_backend_option);
  982. Opts.NumRegisterParameters = Args.getLastArgIntValue(OPT_mregparm, 0, Diags);
  983. Opts.NoGlobalMerge = Args.hasArg(OPT_mno_global_merge);
  984. Opts.NoExecStack = Args.hasArg(OPT_mno_exec_stack);
  985. Opts.RelaxAll = Args.hasArg(OPT_mrelax_all);
  986. Opts.OmitLeafFramePointer = Args.hasArg(OPT_momit_leaf_frame_pointer);
  987. Opts.SaveTempLabels = Args.hasArg(OPT_msave_temp_labels);
  988. Opts.NoDwarf2CFIAsm = Args.hasArg(OPT_fno_dwarf2_cfi_asm);
  989. Opts.SoftFloat = Args.hasArg(OPT_msoft_float);
  990. Opts.UnsafeFPMath = Args.hasArg(OPT_cl_unsafe_math_optimizations) ||
  991. Args.hasArg(OPT_cl_fast_relaxed_math);
  992. Opts.UnwindTables = Args.hasArg(OPT_munwind_tables);
  993. Opts.RelocationModel = Args.getLastArgValue(OPT_mrelocation_model, "pic");
  994. Opts.FunctionSections = Args.hasArg(OPT_ffunction_sections);
  995. Opts.DataSections = Args.hasArg(OPT_fdata_sections);
  996. Opts.MainFileName = Args.getLastArgValue(OPT_main_file_name);
  997. Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier);
  998. Opts.InstrumentFunctions = Args.hasArg(OPT_finstrument_functions);
  999. Opts.InstrumentForProfiling = Args.hasArg(OPT_pg);
  1000. Opts.EmitGcovArcs = Args.hasArg(OPT_femit_coverage_data);
  1001. Opts.EmitGcovNotes = Args.hasArg(OPT_femit_coverage_notes);
  1002. Opts.CoverageFile = Args.getLastArgValue(OPT_coverage_file);
  1003. if (Arg *A = Args.getLastArg(OPT_fobjc_dispatch_method_EQ)) {
  1004. StringRef Name = A->getValue(Args);
  1005. unsigned Method = llvm::StringSwitch<unsigned>(Name)
  1006. .Case("legacy", CodeGenOptions::Legacy)
  1007. .Case("non-legacy", CodeGenOptions::NonLegacy)
  1008. .Case("mixed", CodeGenOptions::Mixed)
  1009. .Default(~0U);
  1010. if (Method == ~0U)
  1011. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
  1012. else
  1013. Opts.ObjCDispatchMethod = Method;
  1014. }
  1015. }
  1016. static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts,
  1017. ArgList &Args) {
  1018. using namespace cc1options;
  1019. Opts.OutputFile = Args.getLastArgValue(OPT_dependency_file);
  1020. Opts.Targets = Args.getAllArgValues(OPT_MT);
  1021. Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps);
  1022. Opts.UsePhonyTargets = Args.hasArg(OPT_MP);
  1023. Opts.ShowHeaderIncludes = Args.hasArg(OPT_H);
  1024. Opts.HeaderIncludeOutputFile = Args.getLastArgValue(OPT_header_include_file);
  1025. Opts.AddMissingHeaderDeps = Args.hasArg(OPT_MG);
  1026. }
  1027. static void ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
  1028. DiagnosticsEngine &Diags) {
  1029. using namespace cc1options;
  1030. Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
  1031. Opts.IgnoreWarnings = Args.hasArg(OPT_w);
  1032. Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros);
  1033. Opts.Pedantic = Args.hasArg(OPT_pedantic);
  1034. Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors);
  1035. Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics);
  1036. Opts.ShowColors = Args.hasArg(OPT_fcolor_diagnostics);
  1037. Opts.ShowColumn = Args.hasFlag(OPT_fshow_column,
  1038. OPT_fno_show_column,
  1039. /*Default=*/true);
  1040. Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info);
  1041. Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location);
  1042. Opts.ShowNames = Args.hasArg(OPT_fdiagnostics_show_name);
  1043. Opts.ShowOptionNames = Args.hasArg(OPT_fdiagnostics_show_option);
  1044. // Default behavior is to not to show note include stacks.
  1045. Opts.ShowNoteIncludeStack = false;
  1046. if (Arg *A = Args.getLastArg(OPT_fdiagnostics_show_note_include_stack,
  1047. OPT_fno_diagnostics_show_note_include_stack))
  1048. if (A->getOption().matches(OPT_fdiagnostics_show_note_include_stack))
  1049. Opts.ShowNoteIncludeStack = true;
  1050. StringRef ShowOverloads =
  1051. Args.getLastArgValue(OPT_fshow_overloads_EQ, "all");
  1052. if (ShowOverloads == "best")
  1053. Opts.ShowOverloads = DiagnosticsEngine::Ovl_Best;
  1054. else if (ShowOverloads == "all")
  1055. Opts.ShowOverloads = DiagnosticsEngine::Ovl_All;
  1056. else
  1057. Diags.Report(diag::err_drv_invalid_value)
  1058. << Args.getLastArg(OPT_fshow_overloads_EQ)->getAsString(Args)
  1059. << ShowOverloads;
  1060. StringRef ShowCategory =
  1061. Args.getLastArgValue(OPT_fdiagnostics_show_category, "none");
  1062. if (ShowCategory == "none")
  1063. Opts.ShowCategories = 0;
  1064. else if (ShowCategory == "id")
  1065. Opts.ShowCategories = 1;
  1066. else if (ShowCategory == "name")
  1067. Opts.ShowCategories = 2;
  1068. else
  1069. Diags.Report(diag::err_drv_invalid_value)
  1070. << Args.getLastArg(OPT_fdiagnostics_show_category)->getAsString(Args)
  1071. << ShowCategory;
  1072. StringRef Format =
  1073. Args.getLastArgValue(OPT_fdiagnostics_format, "clang");
  1074. if (Format == "clang")
  1075. Opts.Format = DiagnosticOptions::Clang;
  1076. else if (Format == "msvc")
  1077. Opts.Format = DiagnosticOptions::Msvc;
  1078. else if (Format == "vi")
  1079. Opts.Format = DiagnosticOptions::Vi;
  1080. else
  1081. Diags.Report(diag::err_drv_invalid_value)
  1082. << Args.getLastArg(OPT_fdiagnostics_format)->getAsString(Args)
  1083. << Format;
  1084. Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info);
  1085. Opts.ShowParseableFixits = Args.hasArg(OPT_fdiagnostics_parseable_fixits);
  1086. Opts.VerifyDiagnostics = Args.hasArg(OPT_verify);
  1087. Opts.ErrorLimit = Args.getLastArgIntValue(OPT_ferror_limit, 0, Diags);
  1088. Opts.MacroBacktraceLimit
  1089. = Args.getLastArgIntValue(OPT_fmacro_backtrace_limit,
  1090. DiagnosticOptions::DefaultMacroBacktraceLimit, Diags);
  1091. Opts.TemplateBacktraceLimit
  1092. = Args.getLastArgIntValue(OPT_ftemplate_backtrace_limit,
  1093. DiagnosticOptions::DefaultTemplateBacktraceLimit,
  1094. Diags);
  1095. Opts.TabStop = Args.getLastArgIntValue(OPT_ftabstop,
  1096. DiagnosticOptions::DefaultTabStop, Diags);
  1097. if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) {
  1098. Diags.Report(diag::warn_ignoring_ftabstop_value)
  1099. << Opts.TabStop << DiagnosticOptions::DefaultTabStop;
  1100. Opts.TabStop = DiagnosticOptions::DefaultTabStop;
  1101. }
  1102. Opts.MessageLength = Args.getLastArgIntValue(OPT_fmessage_length, 0, Diags);
  1103. Opts.DumpBuildInformation = Args.getLastArgValue(OPT_dump_build_information);
  1104. Opts.Warnings = Args.getAllArgValues(OPT_W);
  1105. }
  1106. static void ParseFileSystemArgs(FileSystemOptions &Opts, ArgList &Args) {
  1107. Opts.WorkingDir = Args.getLastArgValue(OPT_working_directory);
  1108. }
  1109. static InputKind ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args,
  1110. DiagnosticsEngine &Diags) {
  1111. using namespace cc1options;
  1112. Opts.ProgramAction = frontend::ParseSyntaxOnly;
  1113. if (const Arg *A = Args.getLastArg(OPT_Action_Group)) {
  1114. switch (A->getOption().getID()) {
  1115. default:
  1116. llvm_unreachable("Invalid option in group!");
  1117. case OPT_ast_dump:
  1118. Opts.ProgramAction = frontend::ASTDump; break;
  1119. case OPT_ast_dump_xml:
  1120. Opts.ProgramAction = frontend::ASTDumpXML; break;
  1121. case OPT_ast_print:
  1122. Opts.ProgramAction = frontend::ASTPrint; break;
  1123. case OPT_ast_view:
  1124. Opts.ProgramAction = frontend::ASTView; break;
  1125. case OPT_dump_raw_tokens:
  1126. Opts.ProgramAction = frontend::DumpRawTokens; break;
  1127. case OPT_dump_tokens:
  1128. Opts.ProgramAction = frontend::DumpTokens; break;
  1129. case OPT_S:
  1130. Opts.ProgramAction = frontend::EmitAssembly; break;
  1131. case OPT_emit_llvm_bc:
  1132. Opts.ProgramAction = frontend::EmitBC; break;
  1133. case OPT_emit_html:
  1134. Opts.ProgramAction = frontend::EmitHTML; break;
  1135. case OPT_emit_llvm:
  1136. Opts.ProgramAction = frontend::EmitLLVM; break;
  1137. case OPT_emit_llvm_only:
  1138. Opts.ProgramAction = frontend::EmitLLVMOnly; break;
  1139. case OPT_emit_codegen_only:
  1140. Opts.ProgramAction = frontend::EmitCodeGenOnly; break;
  1141. case OPT_emit_obj:
  1142. Opts.ProgramAction = frontend::EmitObj; break;
  1143. case OPT_fixit_EQ:
  1144. Opts.FixItSuffix = A->getValue(Args);
  1145. // fall-through!
  1146. case OPT_fixit:
  1147. Opts.ProgramAction = frontend::FixIt; break;
  1148. case OPT_emit_module:
  1149. Opts.ProgramAction = frontend::GenerateModule; break;
  1150. case OPT_emit_pch:
  1151. Opts.ProgramAction = frontend::GeneratePCH; break;
  1152. case OPT_emit_pth:
  1153. Opts.ProgramAction = frontend::GeneratePTH; break;
  1154. case OPT_init_only:
  1155. Opts.ProgramAction = frontend::InitOnly; break;
  1156. case OPT_fsyntax_only:
  1157. Opts.ProgramAction = frontend::ParseSyntaxOnly; break;
  1158. case OPT_print_decl_contexts:
  1159. Opts.ProgramAction = frontend::PrintDeclContext; break;
  1160. case OPT_print_preamble:
  1161. Opts.ProgramAction = frontend::PrintPreamble; break;
  1162. case OPT_E:
  1163. Opts.ProgramAction = frontend::PrintPreprocessedInput; break;
  1164. case OPT_rewrite_macros:
  1165. Opts.ProgramAction = frontend::RewriteMacros; break;
  1166. case OPT_rewrite_objc:
  1167. Opts.ProgramAction = frontend::RewriteObjC; break;
  1168. case OPT_rewrite_test:
  1169. Opts.ProgramAction = frontend::RewriteTest; break;
  1170. case OPT_analyze:
  1171. Opts.ProgramAction = frontend::RunAnalysis; break;
  1172. case OPT_Eonly:
  1173. Opts.ProgramAction = frontend::RunPreprocessorOnly; break;
  1174. }
  1175. }
  1176. if (const Arg* A = Args.getLastArg(OPT_plugin)) {
  1177. Opts.Plugins.push_back(A->getValue(Args,0));
  1178. Opts.ProgramAction = frontend::PluginAction;
  1179. Opts.ActionName = A->getValue(Args);
  1180. for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
  1181. end = Args.filtered_end(); it != end; ++it) {
  1182. if ((*it)->getValue(Args, 0) == Opts.ActionName)
  1183. Opts.PluginArgs.push_back((*it)->getValue(Args, 1));
  1184. }
  1185. }
  1186. Opts.AddPluginActions = Args.getAllArgValues(OPT_add_plugin);
  1187. Opts.AddPluginArgs.resize(Opts.AddPluginActions.size());
  1188. for (int i = 0, e = Opts.AddPluginActions.size(); i != e; ++i) {
  1189. for (arg_iterator it = Args.filtered_begin(OPT_plugin_arg),
  1190. end = Args.filtered_end(); it != end; ++it) {
  1191. if ((*it)->getValue(Args, 0) == Opts.AddPluginActions[i])
  1192. Opts.AddPluginArgs[i].push_back((*it)->getValue(Args, 1));
  1193. }
  1194. }
  1195. if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) {
  1196. Opts.CodeCompletionAt =
  1197. ParsedSourceLocation::FromString(A->getValue(Args));
  1198. if (Opts.CodeCompletionAt.FileName.empty())
  1199. Diags.Report(diag::err_drv_invalid_value)
  1200. << A->getAsString(Args) << A->getValue(Args);
  1201. }
  1202. Opts.DisableFree = Args.hasArg(OPT_disable_free);
  1203. Opts.OutputFile = Args.getLastArgValue(OPT_o);
  1204. Opts.Plugins = Args.getAllArgValues(OPT_load);
  1205. Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch);
  1206. Opts.ShowHelp = Args.hasArg(OPT_help);
  1207. Opts.ShowMacrosInCodeCompletion = Args.hasArg(OPT_code_completion_macros);
  1208. Opts.ShowCodePatternsInCodeCompletion
  1209. = Args.hasArg(OPT_code_completion_patterns);
  1210. Opts.ShowGlobalSymbolsInCodeCompletion
  1211. = !Args.hasArg(OPT_no_code_completion_globals);
  1212. Opts.ShowStats = Args.hasArg(OPT_print_stats);
  1213. Opts.ShowTimers = Args.hasArg(OPT_ftime_report);
  1214. Opts.ShowVersion = Args.hasArg(OPT_version);
  1215. Opts.ASTMergeFiles = Args.getAllArgValues(OPT_ast_merge);
  1216. Opts.LLVMArgs = Args.getAllArgValues(OPT_mllvm);
  1217. Opts.FixWhatYouCan = Args.hasArg(OPT_fix_what_you_can);
  1218. Opts.ARCMTAction = FrontendOptions::ARCMT_None;
  1219. if (const Arg *A = Args.getLastArg(OPT_arcmt_check,
  1220. OPT_arcmt_modify,
  1221. OPT_arcmt_migrate)) {
  1222. switch (A->getOption().getID()) {
  1223. default:
  1224. llvm_unreachable("missed a case");
  1225. case OPT_arcmt_check:
  1226. Opts.ARCMTAction = FrontendOptions::ARCMT_Check;
  1227. break;
  1228. case OPT_arcmt_modify:
  1229. Opts.ARCMTAction = FrontendOptions::ARCMT_Modify;
  1230. break;
  1231. case OPT_arcmt_migrate:
  1232. Opts.ARCMTAction = FrontendOptions::ARCMT_Migrate;
  1233. break;
  1234. }
  1235. }
  1236. Opts.ARCMTMigrateDir = Args.getLastArgValue(OPT_arcmt_migrate_directory);
  1237. Opts.ARCMTMigrateReportOut
  1238. = Args.getLastArgValue(OPT_arcmt_migrate_report_output);
  1239. Opts.ARCMTMigrateEmitARCErrors
  1240. = Args.hasArg(OPT_arcmt_migrate_emit_arc_errors);
  1241. InputKind DashX = IK_None;
  1242. if (const Arg *A = Args.getLastArg(OPT_x)) {
  1243. DashX = llvm::StringSwitch<InputKind>(A->getValue(Args))
  1244. .Case("c", IK_C)
  1245. .Case("cl", IK_OpenCL)
  1246. .Case("cuda", IK_CUDA)
  1247. .Case("c++", IK_CXX)
  1248. .Case("objective-c", IK_ObjC)
  1249. .Case("objective-c++", IK_ObjCXX)
  1250. .Case("cpp-output", IK_PreprocessedC)
  1251. .Case("assembler-with-cpp", IK_Asm)
  1252. .Case("c++-cpp-output", IK_PreprocessedCXX)
  1253. .Case("objective-c-cpp-output", IK_PreprocessedObjC)
  1254. .Case("objc-cpp-output", IK_PreprocessedObjC)
  1255. .Case("objective-c++-cpp-output", IK_PreprocessedObjCXX)
  1256. .Case("objc++-cpp-output", IK_PreprocessedObjCXX)
  1257. .Case("c-header", IK_C)
  1258. .Case("objective-c-header", IK_ObjC)
  1259. .Case("c++-header", IK_CXX)
  1260. .Case("objective-c++-header", IK_ObjCXX)
  1261. .Case("ast", IK_AST)
  1262. .Case("ir", IK_LLVM_IR)
  1263. .Default(IK_None);
  1264. if (DashX == IK_None)
  1265. Diags.Report(diag::err_drv_invalid_value)
  1266. << A->getAsString(Args) << A->getValue(Args);
  1267. }
  1268. // '-' is the default input if none is given.
  1269. std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
  1270. Opts.Inputs.clear();
  1271. if (Inputs.empty())
  1272. Inputs.push_back("-");
  1273. for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
  1274. InputKind IK = DashX;
  1275. if (IK == IK_None) {
  1276. IK = FrontendOptions::getInputKindForExtension(
  1277. StringRef(Inputs[i]).rsplit('.').second);
  1278. // FIXME: Remove this hack.
  1279. if (i == 0)
  1280. DashX = IK;
  1281. }
  1282. Opts.Inputs.push_back(std::make_pair(IK, Inputs[i]));
  1283. }
  1284. return DashX;
  1285. }
  1286. std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
  1287. void *MainAddr) {
  1288. llvm::sys::Path P = llvm::sys::Path::GetMainExecutable(Argv0, MainAddr);
  1289. if (!P.isEmpty()) {
  1290. P.eraseComponent(); // Remove /clang from foo/bin/clang
  1291. P.eraseComponent(); // Remove /bin from foo/bin
  1292. // Get foo/lib/clang/<version>/include
  1293. P.appendComponent("lib");
  1294. P.appendComponent("clang");
  1295. P.appendComponent(CLANG_VERSION_STRING);
  1296. }
  1297. return P.str();
  1298. }
  1299. static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) {
  1300. using namespace cc1options;
  1301. Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
  1302. Opts.Verbose = Args.hasArg(OPT_v);
  1303. Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc) &&
  1304. !Args.hasArg(OPT_fms_compatibility);
  1305. Opts.UseStandardIncludes = !Args.hasArg(OPT_nostdinc);
  1306. Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
  1307. if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
  1308. Opts.UseLibcxx = (strcmp(A->getValue(Args), "libc++") == 0);
  1309. Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
  1310. Opts.ModuleCachePath = Args.getLastArgValue(OPT_fmodule_cache_path);
  1311. Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
  1312. // Add -I..., -F..., and -index-header-map options in order.
  1313. bool IsIndexHeaderMap = false;
  1314. for (arg_iterator it = Args.filtered_begin(OPT_I, OPT_F,
  1315. OPT_index_header_map),
  1316. ie = Args.filtered_end(); it != ie; ++it) {
  1317. if ((*it)->getOption().matches(OPT_index_header_map)) {
  1318. // -index-header-map applies to the next -I or -F.
  1319. IsIndexHeaderMap = true;
  1320. continue;
  1321. }
  1322. frontend::IncludeDirGroup Group
  1323. = IsIndexHeaderMap? frontend::IndexHeaderMap : frontend::Angled;
  1324. Opts.AddPath((*it)->getValue(Args), Group, true,
  1325. /*IsFramework=*/ (*it)->getOption().matches(OPT_F), false);
  1326. IsIndexHeaderMap = false;
  1327. }
  1328. // Add -iprefix/-iwith-prefix/-iwithprefixbefore options.
  1329. StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
  1330. for (arg_iterator it = Args.filtered_begin(OPT_iprefix, OPT_iwithprefix,
  1331. OPT_iwithprefixbefore),
  1332. ie = Args.filtered_end(); it != ie; ++it) {
  1333. const Arg *A = *it;
  1334. if (A->getOption().matches(OPT_iprefix))
  1335. Prefix = A->getValue(Args);
  1336. else if (A->getOption().matches(OPT_iwithprefix))
  1337. Opts.AddPath(Prefix.str() + A->getValue(Args),
  1338. frontend::System, false, false, false);
  1339. else
  1340. Opts.AddPath(Prefix.str() + A->getValue(Args),
  1341. frontend::Angled, false, false, false);
  1342. }
  1343. for (arg_iterator it = Args.filtered_begin(OPT_idirafter),
  1344. ie = Args.filtered_end(); it != ie; ++it)
  1345. Opts.AddPath((*it)->getValue(Args), frontend::After, true, false, false);
  1346. for (arg_iterator it = Args.filtered_begin(OPT_iquote),
  1347. ie = Args.filtered_end(); it != ie; ++it)
  1348. Opts.AddPath((*it)->getValue(Args), frontend::Quoted, true, false, false);
  1349. for (arg_iterator it = Args.filtered_begin(OPT_isystem,
  1350. OPT_iwithsysroot), ie = Args.filtered_end(); it != ie; ++it)
  1351. Opts.AddPath((*it)->getValue(Args), frontend::System, true, false,
  1352. !(*it)->getOption().matches(OPT_iwithsysroot));
  1353. // Add the paths for the various language specific isystem flags.
  1354. for (arg_iterator it = Args.filtered_begin(OPT_c_isystem),
  1355. ie = Args.filtered_end(); it != ie; ++it)
  1356. Opts.AddPath((*it)->getValue(Args), frontend::CSystem, true, false, true);
  1357. for (arg_iterator it = Args.filtered_begin(OPT_cxx_isystem),
  1358. ie = Args.filtered_end(); it != ie; ++it)
  1359. Opts.AddPath((*it)->getValue(Args), frontend::CXXSystem, true, false, true);
  1360. for (arg_iterator it = Args.filtered_begin(OPT_objc_isystem),
  1361. ie = Args.filtered_end(); it != ie; ++it)
  1362. Opts.AddPath((*it)->getValue(Args), frontend::ObjCSystem, true, false,true);
  1363. for (arg_iterator it = Args.filtered_begin(OPT_objcxx_isystem),
  1364. ie = Args.filtered_end(); it != ie; ++it)
  1365. Opts.AddPath((*it)->getValue(Args), frontend::ObjCXXSystem, true, false,
  1366. true);
  1367. }
  1368. void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
  1369. LangStandard::Kind LangStd) {
  1370. // Set some properties which depend solely on the input kind; it would be nice
  1371. // to move these to the language standard, and have the driver resolve the
  1372. // input kind + language standard.
  1373. if (IK == IK_Asm) {
  1374. Opts.AsmPreprocessor = 1;
  1375. } else if (IK == IK_ObjC ||
  1376. IK == IK_ObjCXX ||
  1377. IK == IK_PreprocessedObjC ||
  1378. IK == IK_PreprocessedObjCXX) {
  1379. Opts.ObjC1 = Opts.ObjC2 = 1;
  1380. }
  1381. if (LangStd == LangStandard::lang_unspecified) {
  1382. // Based on the base language, pick one.
  1383. switch (IK) {
  1384. case IK_None:
  1385. case IK_AST:
  1386. case IK_LLVM_IR:
  1387. llvm_unreachable("Invalid input kind!");
  1388. case IK_OpenCL:
  1389. LangStd = LangStandard::lang_opencl;
  1390. break;
  1391. case IK_CUDA:
  1392. LangStd = LangStandard::lang_cuda;
  1393. break;
  1394. case IK_Asm:
  1395. case IK_C:
  1396. case IK_PreprocessedC:
  1397. case IK_ObjC:
  1398. case IK_PreprocessedObjC:
  1399. LangStd = LangStandard::lang_gnu99;
  1400. break;
  1401. case IK_CXX:
  1402. case IK_PreprocessedCXX:
  1403. case IK_ObjCXX:
  1404. case IK_PreprocessedObjCXX:
  1405. LangStd = LangStandard::lang_gnucxx98;
  1406. break;
  1407. }
  1408. }
  1409. const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
  1410. Opts.BCPLComment = Std.hasBCPLComments();
  1411. Opts.C99 = Std.isC99();
  1412. Opts.C1X = Std.isC1X();
  1413. Opts.CPlusPlus = Std.isCPlusPlus();
  1414. Opts.CPlusPlus0x = Std.isCPlusPlus0x();
  1415. Opts.Digraphs = Std.hasDigraphs();
  1416. Opts.GNUMode = Std.isGNUMode();
  1417. Opts.GNUInline = !Std.isC99();
  1418. Opts.HexFloats = Std.hasHexFloats();
  1419. Opts.ImplicitInt = Std.hasImplicitInt();
  1420. // OpenCL has some additional defaults.
  1421. if (LangStd == LangStandard::lang_opencl) {
  1422. Opts.OpenCL = 1;
  1423. Opts.AltiVec = 0;
  1424. Opts.CXXOperatorNames = 1;
  1425. Opts.LaxVectorConversions = 0;
  1426. Opts.DefaultFPContract = 1;
  1427. }
  1428. if (LangStd == LangStandard::lang_cuda)
  1429. Opts.CUDA = 1;
  1430. // OpenCL and C++ both have bool, true, false keywords.
  1431. Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
  1432. Opts.GNUKeywords = Opts.GNUMode;
  1433. Opts.CXXOperatorNames = Opts.CPlusPlus;
  1434. // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
  1435. // is specified, or -std is set to a conforming mode.
  1436. Opts.Trigraphs = !Opts.GNUMode;
  1437. Opts.DollarIdents = !Opts.AsmPreprocessor;
  1438. }
  1439. static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
  1440. DiagnosticsEngine &Diags) {
  1441. // FIXME: Cleanup per-file based stuff.
  1442. LangStandard::Kind LangStd = LangStandard::lang_unspecified;
  1443. if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
  1444. LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue(Args))
  1445. #define LANGSTANDARD(id, name, desc, features) \
  1446. .Case(name, LangStandard::lang_##id)
  1447. #include "clang/Frontend/LangStandards.def"
  1448. .Default(LangStandard::lang_unspecified);
  1449. if (LangStd == LangStandard::lang_unspecified)
  1450. Diags.Report(diag::err_drv_invalid_value)
  1451. << A->getAsString(Args) << A->getValue(Args);
  1452. else {
  1453. // Valid standard, check to make sure language and standard are compatable.
  1454. const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
  1455. switch (IK) {
  1456. case IK_C:
  1457. case IK_ObjC:
  1458. case IK_PreprocessedC:
  1459. case IK_PreprocessedObjC:
  1460. if (!(Std.isC89() || Std.isC99()))
  1461. Diags.Report(diag::err_drv_argument_not_allowed_with)
  1462. << A->getAsString(Args) << "C/ObjC";
  1463. break;
  1464. case IK_CXX:
  1465. case IK_ObjCXX:
  1466. case IK_PreprocessedCXX:
  1467. case IK_PreprocessedObjCXX:
  1468. if (!Std.isCPlusPlus())
  1469. Diags.Report(diag::err_drv_argument_not_allowed_with)
  1470. << A->getAsString(Args) << "C++/ObjC++";
  1471. break;
  1472. case IK_OpenCL:
  1473. if (!Std.isC99())
  1474. Diags.Report(diag::err_drv_argument_not_allowed_with)
  1475. << A->getAsString(Args) << "OpenCL";
  1476. break;
  1477. case IK_CUDA:
  1478. if (!Std.isCPlusPlus())
  1479. Diags.Report(diag::err_drv_argument_not_allowed_with)
  1480. << A->getAsString(Args) << "CUDA";
  1481. break;
  1482. default:
  1483. break;
  1484. }
  1485. }
  1486. }
  1487. if (const Arg *A = Args.getLastArg(OPT_cl_std_EQ)) {
  1488. if (strcmp(A->getValue(Args), "CL1.1") != 0) {
  1489. Diags.Report(diag::err_drv_invalid_value)
  1490. << A->getAsString(Args) << A->getValue(Args);
  1491. }
  1492. }
  1493. CompilerInvocation::setLangDefaults(Opts, IK, LangStd);
  1494. // We abuse '-f[no-]gnu-keywords' to force overriding all GNU-extension
  1495. // keywords. This behavior is provided by GCC's poorly named '-fasm' flag,
  1496. // while a subset (the non-C++ GNU keywords) is provided by GCC's
  1497. // '-fgnu-keywords'. Clang conflates the two for simplicity under the single
  1498. // name, as it doesn't seem a useful distinction.
  1499. Opts.GNUKeywords = Args.hasFlag(OPT_fgnu_keywords, OPT_fno_gnu_keywords,
  1500. Opts.GNUKeywords);
  1501. if (Args.hasArg(OPT_fno_operator_names))
  1502. Opts.CXXOperatorNames = 0;
  1503. if (Opts.ObjC1) {
  1504. if (Args.hasArg(OPT_fobjc_gc_only))
  1505. Opts.setGC(LangOptions::GCOnly);
  1506. else if (Args.hasArg(OPT_fobjc_gc))
  1507. Opts.setGC(LangOptions::HybridGC);
  1508. else if (Args.hasArg(OPT_fobjc_arc)) {
  1509. Opts.ObjCAutoRefCount = 1;
  1510. if (Args.hasArg(OPT_fobjc_fragile_abi))
  1511. Diags.Report(diag::err_arc_nonfragile_abi);
  1512. }
  1513. if (Args.hasArg(OPT_fobjc_runtime_has_weak))
  1514. Opts.ObjCRuntimeHasWeak = 1;
  1515. if (Args.hasArg(OPT_fno_objc_infer_related_result_type))
  1516. Opts.ObjCInferRelatedResultType = 0;
  1517. }
  1518. if (Args.hasArg(OPT_fgnu89_inline))
  1519. Opts.GNUInline = 1;
  1520. if (Args.hasArg(OPT_fapple_kext)) {
  1521. if (!Opts.CPlusPlus)
  1522. Diags.Report(diag::warn_c_kext);
  1523. else
  1524. Opts.AppleKext = 1;
  1525. }
  1526. if (Args.hasArg(OPT_print_ivar_layout))
  1527. Opts.ObjCGCBitmapPrint = 1;
  1528. if (Args.hasArg(OPT_fno_constant_cfstrings))
  1529. Opts.NoConstantCFStrings = 1;
  1530. if (Args.hasArg(OPT_faltivec))
  1531. Opts.AltiVec = 1;
  1532. if (Args.hasArg(OPT_pthread))
  1533. Opts.POSIXThreads = 1;
  1534. if (Args.hasArg(OPT_fdelayed_template_parsing))
  1535. Opts.DelayedTemplateParsing = 1;
  1536. StringRef Vis = Args.getLastArgValue(OPT_fvisibility, "default");
  1537. if (Vis == "default")
  1538. Opts.setVisibilityMode(DefaultVisibility);
  1539. else if (Vis == "hidden")
  1540. Opts.setVisibilityMode(HiddenVisibility);
  1541. else if (Vis == "protected")
  1542. Opts.setVisibilityMode(ProtectedVisibility);
  1543. else
  1544. Diags.Report(diag::err_drv_invalid_value)
  1545. << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
  1546. if (Args.hasArg(OPT_fvisibility_inlines_hidden))
  1547. Opts.InlineVisibilityHidden = 1;
  1548. if (Args.hasArg(OPT_ftrapv)) {
  1549. Opts.setSignedOverflowBehavior(LangOptions::SOB_Trapping);
  1550. // Set the handler, if one is specified.
  1551. Opts.OverflowHandler =
  1552. Args.getLastArgValue(OPT_ftrapv_handler);
  1553. }
  1554. else if (Args.hasArg(OPT_fwrapv))
  1555. Opts.setSignedOverflowBehavior(LangOptions::SOB_Defined);
  1556. if (Args.hasArg(OPT_trigraphs))
  1557. Opts.Trigraphs = 1;
  1558. Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
  1559. OPT_fno_dollars_in_identifiers,
  1560. Opts.DollarIdents);
  1561. Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
  1562. Opts.MicrosoftExt = Args.hasArg(OPT_fms_extensions);
  1563. Opts.MicrosoftMode = Args.hasArg(OPT_fms_compatibility);
  1564. Opts.MSCVersion = Args.getLastArgIntValue(OPT_fmsc_version, 0, Diags);
  1565. Opts.Borland = Args.hasArg(OPT_fborland_extensions);
  1566. Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
  1567. Opts.ConstStrings = Args.hasFlag(OPT_fconst_strings, OPT_fno_const_strings,
  1568. Opts.ConstStrings);
  1569. if (Args.hasArg(OPT_fno_lax_vector_conversions))
  1570. Opts.LaxVectorConversions = 0;
  1571. if (Args.hasArg(OPT_fno_threadsafe_statics))
  1572. Opts.ThreadsafeStatics = 0;
  1573. Opts.Exceptions = Args.hasArg(OPT_fexceptions);
  1574. Opts.ObjCExceptions = Args.hasArg(OPT_fobjc_exceptions);
  1575. Opts.CXXExceptions = Args.hasArg(OPT_fcxx_exceptions);
  1576. Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions);
  1577. Opts.TraditionalCPP = Args.hasArg(OPT_traditional_cpp);
  1578. Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
  1579. Opts.Blocks = Args.hasArg(OPT_fblocks);
  1580. Opts.BlocksRuntimeOptional = Args.hasArg(OPT_fblocks_runtime_optional);
  1581. Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
  1582. Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
  1583. Opts.ShortEnums = Args.hasArg(OPT_fshort_enums);
  1584. Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
  1585. Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
  1586. Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
  1587. Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
  1588. Opts.AccessControl = !Args.hasArg(OPT_fno_access_control);
  1589. Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
  1590. Opts.MathErrno = Args.hasArg(OPT_fmath_errno);
  1591. Opts.InstantiationDepth = Args.getLastArgIntValue(OPT_ftemplate_depth, 1024,
  1592. Diags);
  1593. Opts.DelayedTemplateParsing = Args.hasArg(OPT_fdelayed_template_parsing);
  1594. Opts.NumLargeByValueCopy = Args.getLastArgIntValue(OPT_Wlarge_by_value_copy,
  1595. 0, Diags);
  1596. Opts.MSBitfields = Args.hasArg(OPT_mms_bitfields);
  1597. Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
  1598. Opts.ObjCConstantStringClass =
  1599. Args.getLastArgValue(OPT_fconstant_string_class);
  1600. Opts.ObjCNonFragileABI = !Args.hasArg(OPT_fobjc_fragile_abi);
  1601. if (Opts.ObjCNonFragileABI)
  1602. Opts.ObjCNonFragileABI2 = true;
  1603. Opts.ObjCDefaultSynthProperties =
  1604. Args.hasArg(OPT_fobjc_default_synthesize_properties);
  1605. Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
  1606. Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
  1607. Opts.PICLevel = Args.getLastArgIntValue(OPT_pic_level, 0, Diags);
  1608. Opts.Static = Args.hasArg(OPT_static_define);
  1609. Opts.DumpRecordLayouts = Args.hasArg(OPT_fdump_record_layouts);
  1610. Opts.DumpVTableLayouts = Args.hasArg(OPT_fdump_vtable_layouts);
  1611. Opts.SpellChecking = !Args.hasArg(OPT_fno_spell_checking);
  1612. Opts.NoBitFieldTypeAlign = Args.hasArg(OPT_fno_bitfield_type_align);
  1613. Opts.SinglePrecisionConstants = Args.hasArg(OPT_cl_single_precision_constant);
  1614. Opts.FastRelaxedMath = Args.hasArg(OPT_cl_fast_relaxed_math);
  1615. Opts.OptimizeSize = 0;
  1616. Opts.MRTD = Args.hasArg(OPT_mrtd);
  1617. Opts.FakeAddressSpaceMap = Args.hasArg(OPT_ffake_address_space_map);
  1618. Opts.ParseUnknownAnytype = Args.hasArg(OPT_funknown_anytype);
  1619. Opts.DebuggerSupport = Args.hasArg(OPT_fdebugger_support);
  1620. // Record whether the __DEPRECATED define was requested.
  1621. Opts.Deprecated = Args.hasFlag(OPT_fdeprecated_macro,
  1622. OPT_fno_deprecated_macro,
  1623. Opts.Deprecated);
  1624. // FIXME: Eliminate this dependency.
  1625. unsigned Opt = getOptimizationLevel(Args, IK, Diags);
  1626. Opts.Optimize = Opt != 0;
  1627. // This is the __NO_INLINE__ define, which just depends on things like the
  1628. // optimization level and -fno-inline, not actually whether the backend has
  1629. // inlining enabled.
  1630. //
  1631. // FIXME: This is affected by other options (-fno-inline).
  1632. Opts.NoInline = !Opt;
  1633. unsigned SSP = Args.getLastArgIntValue(OPT_stack_protector, 0, Diags);
  1634. switch (SSP) {
  1635. default:
  1636. Diags.Report(diag::err_drv_invalid_value)
  1637. << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
  1638. break;
  1639. case 0: Opts.setStackProtector(LangOptions::SSPOff); break;
  1640. case 1: Opts.setStackProtector(LangOptions::SSPOn); break;
  1641. case 2: Opts.setStackProtector(LangOptions::SSPReq); break;
  1642. }
  1643. }
  1644. static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args,
  1645. FileManager &FileMgr,
  1646. DiagnosticsEngine &Diags) {
  1647. using namespace cc1options;
  1648. Opts.ImplicitPCHInclude = Args.getLastArgValue(OPT_include_pch);
  1649. Opts.ImplicitPTHInclude = Args.getLastArgValue(OPT_include_pth);
  1650. if (const Arg *A = Args.getLastArg(OPT_token_cache))
  1651. Opts.TokenCache = A->getValue(Args);
  1652. else
  1653. Opts.TokenCache = Opts.ImplicitPTHInclude;
  1654. Opts.UsePredefines = !Args.hasArg(OPT_undef);
  1655. Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record);
  1656. Opts.AutoModuleImport = Args.hasArg(OPT_fauto_module_import);
  1657. Opts.DisablePCHValidation = Args.hasArg(OPT_fno_validate_pch);
  1658. Opts.DumpDeserializedPCHDecls = Args.hasArg(OPT_dump_deserialized_pch_decls);
  1659. for (arg_iterator it = Args.filtered_begin(OPT_error_on_deserialized_pch_decl),
  1660. ie = Args.filtered_end(); it != ie; ++it) {
  1661. const Arg *A = *it;
  1662. Opts.DeserializedPCHDeclsToErrorOn.insert(A->getValue(Args));
  1663. }
  1664. if (const Arg *A = Args.getLastArg(OPT_preamble_bytes_EQ)) {
  1665. StringRef Value(A->getValue(Args));
  1666. size_t Comma = Value.find(',');
  1667. unsigned Bytes = 0;
  1668. unsigned EndOfLine = 0;
  1669. if (Comma == StringRef::npos ||
  1670. Value.substr(0, Comma).getAsInteger(10, Bytes) ||
  1671. Value.substr(Comma + 1).getAsInteger(10, EndOfLine))
  1672. Diags.Report(diag::err_drv_preamble_format);
  1673. else {
  1674. Opts.PrecompiledPreambleBytes.first = Bytes;
  1675. Opts.PrecompiledPreambleBytes.second = (EndOfLine != 0);
  1676. }
  1677. }
  1678. // Add macros from the command line.
  1679. for (arg_iterator it = Args.filtered_begin(OPT_D, OPT_U),
  1680. ie = Args.filtered_end(); it != ie; ++it) {
  1681. if ((*it)->getOption().matches(OPT_D))
  1682. Opts.addMacroDef((*it)->getValue(Args));
  1683. else
  1684. Opts.addMacroUndef((*it)->getValue(Args));
  1685. }
  1686. Opts.MacroIncludes = Args.getAllArgValues(OPT_imacros);
  1687. // Add the ordered list of -includes.
  1688. for (arg_iterator it = Args.filtered_begin(OPT_include, OPT_include_pch,
  1689. OPT_include_pth),
  1690. ie = Args.filtered_end(); it != ie; ++it) {
  1691. const Arg *A = *it;
  1692. // PCH is handled specially, we need to extra the original include path.
  1693. if (A->getOption().matches(OPT_include_pch)) {
  1694. std::string OriginalFile =
  1695. ASTReader::getOriginalSourceFile(A->getValue(Args), FileMgr, Diags);
  1696. if (OriginalFile.empty())
  1697. continue;
  1698. Opts.Includes.push_back(OriginalFile);
  1699. } else
  1700. Opts.Includes.push_back(A->getValue(Args));
  1701. }
  1702. for (arg_iterator it = Args.filtered_begin(OPT_chain_include),
  1703. ie = Args.filtered_end(); it != ie; ++it) {
  1704. const Arg *A = *it;
  1705. Opts.ChainedIncludes.push_back(A->getValue(Args));
  1706. }
  1707. // Include 'altivec.h' if -faltivec option present
  1708. if (Args.hasArg(OPT_faltivec))
  1709. Opts.Includes.push_back("altivec.h");
  1710. for (arg_iterator it = Args.filtered_begin(OPT_remap_file),
  1711. ie = Args.filtered_end(); it != ie; ++it) {
  1712. const Arg *A = *it;
  1713. std::pair<StringRef,StringRef> Split =
  1714. StringRef(A->getValue(Args)).split(';');
  1715. if (Split.second.empty()) {
  1716. Diags.Report(diag::err_drv_invalid_remap_file) << A->getAsString(Args);
  1717. continue;
  1718. }
  1719. Opts.addRemappedFile(Split.first, Split.second);
  1720. }
  1721. if (Arg *A = Args.getLastArg(OPT_fobjc_arc_cxxlib_EQ)) {
  1722. StringRef Name = A->getValue(Args);
  1723. unsigned Library = llvm::StringSwitch<unsigned>(Name)
  1724. .Case("libc++", ARCXX_libcxx)
  1725. .Case("libstdc++", ARCXX_libstdcxx)
  1726. .Case("none", ARCXX_nolib)
  1727. .Default(~0U);
  1728. if (Library == ~0U)
  1729. Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Name;
  1730. else
  1731. Opts.ObjCXXARCStandardLibrary = (ObjCXXARCStandardLibraryKind)Library;
  1732. }
  1733. }
  1734. static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts,
  1735. ArgList &Args) {
  1736. using namespace cc1options;
  1737. Opts.ShowCPP = !Args.hasArg(OPT_dM);
  1738. Opts.ShowComments = Args.hasArg(OPT_C);
  1739. Opts.ShowLineMarkers = !Args.hasArg(OPT_P);
  1740. Opts.ShowMacroComments = Args.hasArg(OPT_CC);
  1741. Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD);
  1742. }
  1743. static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) {
  1744. using namespace cc1options;
  1745. Opts.ABI = Args.getLastArgValue(OPT_target_abi);
  1746. Opts.CXXABI = Args.getLastArgValue(OPT_cxx_abi);
  1747. Opts.CPU = Args.getLastArgValue(OPT_target_cpu);
  1748. Opts.Features = Args.getAllArgValues(OPT_target_feature);
  1749. Opts.LinkerVersion = Args.getLastArgValue(OPT_target_linker_version);
  1750. Opts.Triple = llvm::Triple::normalize(Args.getLastArgValue(OPT_triple));
  1751. // Use the host triple if unspecified.
  1752. if (Opts.Triple.empty())
  1753. Opts.Triple = llvm::sys::getHostTriple();
  1754. }
  1755. //
  1756. void CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
  1757. const char *const *ArgBegin,
  1758. const char *const *ArgEnd,
  1759. DiagnosticsEngine &Diags) {
  1760. // Parse the arguments.
  1761. llvm::OwningPtr<OptTable> Opts(createCC1OptTable());
  1762. unsigned MissingArgIndex, MissingArgCount;
  1763. llvm::OwningPtr<InputArgList> Args(
  1764. Opts->ParseArgs(ArgBegin, ArgEnd,MissingArgIndex, MissingArgCount));
  1765. // Check for missing argument error.
  1766. if (MissingArgCount)
  1767. Diags.Report(diag::err_drv_missing_argument)
  1768. << Args->getArgString(MissingArgIndex) << MissingArgCount;
  1769. // Issue errors on unknown arguments.
  1770. for (arg_iterator it = Args->filtered_begin(OPT_UNKNOWN),
  1771. ie = Args->filtered_end(); it != ie; ++it)
  1772. Diags.Report(diag::err_drv_unknown_argument) << (*it)->getAsString(*Args);
  1773. ParseAnalyzerArgs(Res.getAnalyzerOpts(), *Args, Diags);
  1774. ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), *Args);
  1775. ParseDiagnosticArgs(Res.getDiagnosticOpts(), *Args, Diags);
  1776. ParseFileSystemArgs(Res.getFileSystemOpts(), *Args);
  1777. // FIXME: We shouldn't have to pass the DashX option around here
  1778. InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), *Args, Diags);
  1779. ParseCodeGenArgs(Res.getCodeGenOpts(), *Args, DashX, Diags);
  1780. ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), *Args);
  1781. if (DashX != IK_AST && DashX != IK_LLVM_IR) {
  1782. ParseLangArgs(Res.getLangOpts(), *Args, DashX, Diags);
  1783. if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
  1784. Res.getLangOpts().ObjCExceptions = 1;
  1785. }
  1786. // FIXME: ParsePreprocessorArgs uses the FileManager to read the contents of
  1787. // PCH file and find the original header name. Remove the need to do that in
  1788. // ParsePreprocessorArgs and remove the FileManager
  1789. // parameters from the function and the "FileManager.h" #include.
  1790. FileManager FileMgr(Res.getFileSystemOpts());
  1791. ParsePreprocessorArgs(Res.getPreprocessorOpts(), *Args, FileMgr, Diags);
  1792. ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), *Args);
  1793. ParseTargetArgs(Res.getTargetOpts(), *Args);
  1794. }
  1795. namespace {
  1796. class ModuleSignature {
  1797. llvm::SmallVector<uint64_t, 16> Data;
  1798. unsigned CurBit;
  1799. uint64_t CurValue;
  1800. public:
  1801. ModuleSignature() : CurBit(0), CurValue(0) { }
  1802. void add(uint64_t Value, unsigned Bits);
  1803. void add(StringRef Value);
  1804. void flush();
  1805. llvm::APInt getAsInteger() const;
  1806. };
  1807. }
  1808. void ModuleSignature::add(uint64_t Value, unsigned int NumBits) {
  1809. CurValue |= Value << CurBit;
  1810. if (CurBit + NumBits < 64) {
  1811. CurBit += NumBits;
  1812. return;
  1813. }
  1814. // Add the current word.
  1815. Data.push_back(CurValue);
  1816. if (CurBit)
  1817. CurValue = Value >> (64-CurBit);
  1818. else
  1819. CurValue = 0;
  1820. CurBit = (CurBit+NumBits) & 63;
  1821. }
  1822. void ModuleSignature::flush() {
  1823. if (CurBit == 0)
  1824. return;
  1825. Data.push_back(CurValue);
  1826. CurBit = 0;
  1827. CurValue = 0;
  1828. }
  1829. void ModuleSignature::add(StringRef Value) {
  1830. for (StringRef::iterator I = Value.begin(), IEnd = Value.end(); I != IEnd;++I)
  1831. add(*I, 8);
  1832. }
  1833. llvm::APInt ModuleSignature::getAsInteger() const {
  1834. return llvm::APInt(Data.size() * 64, Data);
  1835. }
  1836. std::string CompilerInvocation::getModuleHash() const {
  1837. ModuleSignature Signature;
  1838. // Start the signature with the compiler version.
  1839. Signature.add(getClangFullRepositoryVersion());
  1840. // Extend the signature with the language options
  1841. #define LANGOPT(Name, Bits, Default, Description) \
  1842. Signature.add(LangOpts.Name, Bits);
  1843. #define ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
  1844. Signature.add(static_cast<unsigned>(LangOpts.get##Name()), Bits);
  1845. #define BENIGN_LANGOPT(Name, Bits, Default, Description)
  1846. #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description)
  1847. #include "clang/Basic/LangOptions.def"
  1848. // Extend the signature with the target triple
  1849. llvm::Triple T(TargetOpts.Triple);
  1850. Signature.add((unsigned)T.getArch(), 5);
  1851. Signature.add((unsigned)T.getVendor(), 4);
  1852. Signature.add((unsigned)T.getOS(), 5);
  1853. Signature.add((unsigned)T.getEnvironment(), 4);
  1854. // Extend the signature with preprocessor options.
  1855. Signature.add(getPreprocessorOpts().UsePredefines, 1);
  1856. Signature.add(getPreprocessorOpts().DetailedRecord, 1);
  1857. // We've generated the signature. Treat it as one large APInt that we'll
  1858. // encode in base-36 and return.
  1859. Signature.flush();
  1860. return Signature.getAsInteger().toString(36, /*Signed=*/false);
  1861. }