CompilerInvocation.cpp revision 205408
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 10#include "clang/Frontend/CompilerInvocation.h" 11#include "clang/Basic/Diagnostic.h" 12#include "clang/Basic/Version.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/Frontend/PCHReader.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/Support/ErrorHandling.h" 27#include "llvm/System/Host.h" 28#include "llvm/System/Path.h" 29using namespace clang; 30 31static const char *getAnalysisName(Analyses Kind) { 32 switch (Kind) { 33 default: 34 llvm_unreachable("Unknown analysis kind!"); 35#define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE)\ 36 case NAME: return "-" CMDFLAG; 37#include "clang/Frontend/Analyses.def" 38 } 39} 40 41static const char *getAnalysisStoreName(AnalysisStores Kind) { 42 switch (Kind) { 43 default: 44 llvm_unreachable("Unknown analysis store!"); 45#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \ 46 case NAME##Model: return CMDFLAG; 47#include "clang/Frontend/Analyses.def" 48 } 49} 50 51static const char *getAnalysisConstraintName(AnalysisConstraints Kind) { 52 switch (Kind) { 53 default: 54 llvm_unreachable("Unknown analysis constraints!"); 55#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \ 56 case NAME##Model: return CMDFLAG; 57#include "clang/Frontend/Analyses.def" 58 } 59} 60 61static const char *getAnalysisDiagClientName(AnalysisDiagClients Kind) { 62 switch (Kind) { 63 default: 64 llvm_unreachable("Unknown analysis client!"); 65#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREATE) \ 66 case PD_##NAME: return CMDFLAG; 67#include "clang/Frontend/Analyses.def" 68 } 69} 70 71//===----------------------------------------------------------------------===// 72// Serialization (to args) 73//===----------------------------------------------------------------------===// 74 75static void AnalyzerOptsToArgs(const AnalyzerOptions &Opts, 76 std::vector<std::string> &Res) { 77 for (unsigned i = 0, e = Opts.AnalysisList.size(); i != e; ++i) 78 Res.push_back(getAnalysisName(Opts.AnalysisList[i])); 79 if (Opts.AnalysisStoreOpt != BasicStoreModel) { 80 Res.push_back("-analyzer-store"); 81 Res.push_back(getAnalysisStoreName(Opts.AnalysisStoreOpt)); 82 } 83 if (Opts.AnalysisConstraintsOpt != RangeConstraintsModel) { 84 Res.push_back("-analyzer-constraints"); 85 Res.push_back(getAnalysisConstraintName(Opts.AnalysisConstraintsOpt)); 86 } 87 if (Opts.AnalysisDiagOpt != PD_HTML) { 88 Res.push_back("-analyzer-output"); 89 Res.push_back(getAnalysisDiagClientName(Opts.AnalysisDiagOpt)); 90 } 91 if (!Opts.AnalyzeSpecificFunction.empty()) { 92 Res.push_back("-analyze-function"); 93 Res.push_back(Opts.AnalyzeSpecificFunction); 94 } 95 if (Opts.AnalyzeAll) 96 Res.push_back("-analyzer-opt-analyze-headers"); 97 if (Opts.AnalyzerDisplayProgress) 98 Res.push_back("-analyzer-display-progress"); 99 if (Opts.AnalyzeNestedBlocks) 100 Res.push_back("-analyzer-opt-analyze-nested-blocks"); 101 if (Opts.EagerlyAssume) 102 Res.push_back("-analyzer-eagerly-assume"); 103 if (!Opts.PurgeDead) 104 Res.push_back("-analyzer-no-purge-dead"); 105 if (Opts.TrimGraph) 106 Res.push_back("-trim-egraph"); 107 if (Opts.VisualizeEGDot) 108 Res.push_back("-analyzer-viz-egraph-graphviz"); 109 if (Opts.VisualizeEGDot) 110 Res.push_back("-analyzer-viz-egraph-ubigraph"); 111 if (Opts.EnableExperimentalChecks) 112 Res.push_back("-analyzer-experimental-checks"); 113 if (Opts.EnableExperimentalInternalChecks) 114 Res.push_back("-analyzer-experimental-internal-checks"); 115} 116 117static 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.MergeAllConstants) 130 Res.push_back("-fno-merge-all-constants"); 131 if (Opts.NoCommon) 132 Res.push_back("-fno-common"); 133 if (Opts.NoImplicitFloat) 134 Res.push_back("-no-implicit-float"); 135 if (Opts.OptimizeSize) { 136 assert(Opts.OptimizationLevel == 2 && "Invalid options!"); 137 Res.push_back("-Os"); 138 } else if (Opts.OptimizationLevel != 0) 139 Res.push_back("-O" + llvm::utostr(Opts.OptimizationLevel)); 140 if (!Opts.MainFileName.empty()) { 141 Res.push_back("-main-file-name"); 142 Res.push_back(Opts.MainFileName); 143 } 144 // SimplifyLibCalls is only derived. 145 // TimePasses is only derived. 146 // UnitAtATime is unused. 147 // UnrollLoops is only derived. 148 // VerifyModule is only derived. 149 // Inlining is only derived. 150 151 if (Opts.AsmVerbose) 152 Res.push_back("-masm-verbose"); 153 if (!Opts.CodeModel.empty()) { 154 Res.push_back("-mcode-model"); 155 Res.push_back(Opts.CodeModel); 156 } 157 if (!Opts.CXAAtExit) 158 Res.push_back("-fno-use-cxa-atexit"); 159 if (Opts.CXXCtorDtorAliases) 160 Res.push_back("-mconstructor-aliases"); 161 if (!Opts.DebugPass.empty()) { 162 Res.push_back("-mdebug-pass"); 163 Res.push_back(Opts.DebugPass); 164 } 165 if (Opts.DisableFPElim) 166 Res.push_back("-mdisable-fp-elim"); 167 if (!Opts.FloatABI.empty()) { 168 Res.push_back("-mfloat-abi"); 169 Res.push_back(Opts.FloatABI); 170 } 171 if (!Opts.LimitFloatPrecision.empty()) { 172 Res.push_back("-mlimit-float-precision"); 173 Res.push_back(Opts.LimitFloatPrecision); 174 } 175 if (Opts.NoZeroInitializedInBSS) 176 Res.push_back("-mno-zero-initialized-bss"); 177 if (Opts.ObjCLegacyDispatch) 178 Res.push_back("-fobjc-legacy-dispatch"); 179 if (Opts.SoftFloat) 180 Res.push_back("-msoft-float"); 181 if (Opts.UnwindTables) 182 Res.push_back("-munwind-tables"); 183 if (Opts.RelocationModel != "pic") { 184 Res.push_back("-mrelocation-model"); 185 Res.push_back(Opts.RelocationModel); 186 } 187 if (!Opts.VerifyModule) 188 Res.push_back("-disable-llvm-verifier"); 189} 190 191static void DependencyOutputOptsToArgs(const DependencyOutputOptions &Opts, 192 std::vector<std::string> &Res) { 193 if (Opts.IncludeSystemHeaders) 194 Res.push_back("-sys-header-deps"); 195 if (Opts.UsePhonyTargets) 196 Res.push_back("-MP"); 197 if (!Opts.OutputFile.empty()) { 198 Res.push_back("-dependency-file"); 199 Res.push_back(Opts.OutputFile); 200 } 201 for (unsigned i = 0, e = Opts.Targets.size(); i != e; ++i) { 202 Res.push_back("-MT"); 203 Res.push_back(Opts.Targets[i]); 204 } 205} 206 207static void DiagnosticOptsToArgs(const DiagnosticOptions &Opts, 208 std::vector<std::string> &Res) { 209 if (Opts.IgnoreWarnings) 210 Res.push_back("-w"); 211 if (Opts.NoRewriteMacros) 212 Res.push_back("-Wno-rewrite-macros"); 213 if (Opts.Pedantic) 214 Res.push_back("-pedantic"); 215 if (Opts.PedanticErrors) 216 Res.push_back("-pedantic-errors"); 217 if (!Opts.ShowColumn) 218 Res.push_back("-fno-show-column"); 219 if (!Opts.ShowLocation) 220 Res.push_back("-fno-show-source-location"); 221 if (!Opts.ShowCarets) 222 Res.push_back("-fno-caret-diagnostics"); 223 if (!Opts.ShowFixits) 224 Res.push_back("-fno-diagnostics-fixit-info"); 225 if (Opts.ShowSourceRanges) 226 Res.push_back("-fdiagnostics-print-source-range-info"); 227 if (Opts.ShowColors) 228 Res.push_back("-fcolor-diagnostics"); 229 if (Opts.VerifyDiagnostics) 230 Res.push_back("-verify"); 231 if (Opts.BinaryOutput) 232 Res.push_back("-fdiagnostics-binary"); 233 if (Opts.ShowOptionNames) 234 Res.push_back("-fdiagnostics-show-option"); 235 if (Opts.TabStop != DiagnosticOptions::DefaultTabStop) { 236 Res.push_back("-ftabstop"); 237 Res.push_back(llvm::utostr(Opts.TabStop)); 238 } 239 if (Opts.MessageLength) { 240 Res.push_back("-fmessage-length"); 241 Res.push_back(llvm::utostr(Opts.MessageLength)); 242 } 243 if (!Opts.DumpBuildInformation.empty()) { 244 Res.push_back("-dump-build-information"); 245 Res.push_back(Opts.DumpBuildInformation); 246 } 247 for (unsigned i = 0, e = Opts.Warnings.size(); i != e; ++i) 248 Res.push_back("-W" + Opts.Warnings[i]); 249} 250 251static const char *getInputKindName(FrontendOptions::InputKind Kind) { 252 switch (Kind) { 253 case FrontendOptions::IK_None: break; 254 case FrontendOptions::IK_AST: return "ast"; 255 case FrontendOptions::IK_Asm: return "assembler-with-cpp"; 256 case FrontendOptions::IK_C: return "c"; 257 case FrontendOptions::IK_CXX: return "c++"; 258 case FrontendOptions::IK_ObjC: return "objective-c"; 259 case FrontendOptions::IK_ObjCXX: return "objective-c++"; 260 case FrontendOptions::IK_OpenCL: return "cl"; 261 case FrontendOptions::IK_PreprocessedC: return "cpp-output"; 262 case FrontendOptions::IK_PreprocessedCXX: return "c++-cpp-output"; 263 case FrontendOptions::IK_PreprocessedObjC: return "objective-c-cpp-output"; 264 case FrontendOptions::IK_PreprocessedObjCXX:return "objective-c++-cpp-output"; 265 } 266 267 llvm_unreachable("Unexpected language kind!"); 268 return 0; 269} 270 271static const char *getActionName(frontend::ActionKind Kind) { 272 switch (Kind) { 273 case frontend::PluginAction: 274 case frontend::InheritanceView: 275 llvm_unreachable("Invalid kind!"); 276 277 case frontend::ASTDump: return "-ast-dump"; 278 case frontend::ASTPrint: return "-ast-print"; 279 case frontend::ASTPrintXML: return "-ast-print-xml"; 280 case frontend::ASTView: return "-ast-view"; 281 case frontend::DumpRawTokens: return "-dump-raw-tokens"; 282 case frontend::DumpRecordLayouts: return "-dump-record-layouts"; 283 case frontend::DumpTokens: return "-dump-tokens"; 284 case frontend::EmitAssembly: return "-S"; 285 case frontend::EmitBC: return "-emit-llvm-bc"; 286 case frontend::EmitHTML: return "-emit-html"; 287 case frontend::EmitLLVM: return "-emit-llvm"; 288 case frontend::EmitLLVMOnly: return "-emit-llvm-only"; 289 case frontend::EmitObj: return "-emit-obj"; 290 case frontend::FixIt: return "-fixit"; 291 case frontend::GeneratePCH: return "-emit-pch"; 292 case frontend::GeneratePTH: return "-emit-pth"; 293 case frontend::InitOnly: return "-init-only"; 294 case frontend::ParseNoop: return "-parse-noop"; 295 case frontend::ParsePrintCallbacks: return "-parse-print-callbacks"; 296 case frontend::ParseSyntaxOnly: return "-fsyntax-only"; 297 case frontend::PrintDeclContext: return "-print-decl-contexts"; 298 case frontend::PrintPreprocessedInput: return "-E"; 299 case frontend::RewriteMacros: return "-rewrite-macros"; 300 case frontend::RewriteObjC: return "-rewrite-objc"; 301 case frontend::RewriteTest: return "-rewrite-test"; 302 case frontend::RunAnalysis: return "-analyze"; 303 case frontend::RunPreprocessorOnly: return "-Eonly"; 304 } 305 306 llvm_unreachable("Unexpected language kind!"); 307 return 0; 308} 309 310static void FrontendOptsToArgs(const FrontendOptions &Opts, 311 std::vector<std::string> &Res) { 312 if (!Opts.DebugCodeCompletionPrinter) 313 Res.push_back("-no-code-completion-debug-printer"); 314 if (Opts.DisableFree) 315 Res.push_back("-disable-free"); 316 if (Opts.RelocatablePCH) 317 Res.push_back("-relocatable-pch"); 318 if (Opts.ShowHelp) 319 Res.push_back("-help"); 320 if (Opts.ShowMacrosInCodeCompletion) 321 Res.push_back("-code-completion-macros"); 322 if (Opts.ShowStats) 323 Res.push_back("-print-stats"); 324 if (Opts.ShowTimers) 325 Res.push_back("-ftime-report"); 326 if (Opts.ShowVersion) 327 Res.push_back("-version"); 328 329 bool NeedLang = false; 330 for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i) 331 if (FrontendOptions::getInputKindForExtension(Opts.Inputs[i].second) != 332 Opts.Inputs[i].first) 333 NeedLang = true; 334 if (NeedLang) { 335 Res.push_back("-x"); 336 Res.push_back(getInputKindName(Opts.Inputs[0].first)); 337 } 338 for (unsigned i = 0, e = Opts.Inputs.size(); i != e; ++i) { 339 assert((!NeedLang || Opts.Inputs[i].first == Opts.Inputs[0].first) && 340 "Unable to represent this input vector!"); 341 Res.push_back(Opts.Inputs[i].second); 342 } 343 344 if (!Opts.OutputFile.empty()) { 345 Res.push_back("-o"); 346 Res.push_back(Opts.OutputFile); 347 } 348 if (!Opts.ViewClassInheritance.empty()) { 349 Res.push_back("-cxx-inheritance-view"); 350 Res.push_back(Opts.ViewClassInheritance); 351 } 352 for (unsigned i = 0, e = Opts.FixItLocations.size(); i != e; ++i) { 353 Res.push_back("-fixit-at"); 354 Res.push_back(Opts.FixItLocations[i].FileName + ":" + 355 llvm::utostr(Opts.FixItLocations[i].Line) + ":" + 356 llvm::utostr(Opts.FixItLocations[i].Column)); 357 } 358 if (!Opts.CodeCompletionAt.FileName.empty()) { 359 Res.push_back("-code-completion-at"); 360 Res.push_back(Opts.CodeCompletionAt.FileName + ":" + 361 llvm::utostr(Opts.CodeCompletionAt.Line) + ":" + 362 llvm::utostr(Opts.CodeCompletionAt.Column)); 363 } 364 if (Opts.ProgramAction != frontend::InheritanceView && 365 Opts.ProgramAction != frontend::PluginAction) 366 Res.push_back(getActionName(Opts.ProgramAction)); 367 if (!Opts.ActionName.empty()) { 368 Res.push_back("-plugin"); 369 Res.push_back(Opts.ActionName); 370 } 371 for (unsigned i = 0, e = Opts.Plugins.size(); i != e; ++i) { 372 Res.push_back("-load"); 373 Res.push_back(Opts.Plugins[i]); 374 } 375 for (unsigned i = 0, e = Opts.ASTMergeFiles.size(); i != e; ++i) { 376 Res.push_back("-ast-merge"); 377 Res.push_back(Opts.ASTMergeFiles[i]); 378 } 379} 380 381static void HeaderSearchOptsToArgs(const HeaderSearchOptions &Opts, 382 std::vector<std::string> &Res) { 383 if (Opts.Sysroot != "/") { 384 Res.push_back("-isysroot"); 385 Res.push_back(Opts.Sysroot); 386 } 387 388 /// User specified include entries. 389 for (unsigned i = 0, e = Opts.UserEntries.size(); i != e; ++i) { 390 const HeaderSearchOptions::Entry &E = Opts.UserEntries[i]; 391 if (E.IsFramework && (E.Group != frontend::Angled || !E.IsUserSupplied)) 392 llvm::llvm_report_error("Invalid option set!"); 393 if (E.IsUserSupplied) { 394 if (E.Group == frontend::After) { 395 Res.push_back("-idirafter"); 396 } else if (E.Group == frontend::Quoted) { 397 Res.push_back("-iquote"); 398 } else if (E.Group == frontend::System) { 399 Res.push_back("-isystem"); 400 } else { 401 assert(E.Group == frontend::Angled && "Invalid group!"); 402 Res.push_back(E.IsFramework ? "-F" : "-I"); 403 } 404 } else { 405 if (E.Group != frontend::Angled && E.Group != frontend::System) 406 llvm::llvm_report_error("Invalid option set!"); 407 Res.push_back(E.Group == frontend::Angled ? "-iwithprefixbefore" : 408 "-iwithprefix"); 409 } 410 Res.push_back(E.Path); 411 } 412 413 if (!Opts.EnvIncPath.empty()) { 414 // FIXME: Provide an option for this, and move env detection to driver. 415 llvm::llvm_report_error("Not yet implemented!"); 416 } 417 if (!Opts.CEnvIncPath.empty()) { 418 // FIXME: Provide an option for this, and move env detection to driver. 419 llvm::llvm_report_error("Not yet implemented!"); 420 } 421 if (!Opts.ObjCEnvIncPath.empty()) { 422 // FIXME: Provide an option for this, and move env detection to driver. 423 llvm::llvm_report_error("Not yet implemented!"); 424 } 425 if (!Opts.CXXEnvIncPath.empty()) { 426 // FIXME: Provide an option for this, and move env detection to driver. 427 llvm::llvm_report_error("Not yet implemented!"); 428 } 429 if (!Opts.ObjCXXEnvIncPath.empty()) { 430 // FIXME: Provide an option for this, and move env detection to driver. 431 llvm::llvm_report_error("Not yet implemented!"); 432 } 433 if (!Opts.ResourceDir.empty()) { 434 Res.push_back("-resource-dir"); 435 Res.push_back(Opts.ResourceDir); 436 } 437 if (!Opts.UseStandardIncludes) 438 Res.push_back("-nostdinc"); 439 if (Opts.Verbose) 440 Res.push_back("-v"); 441} 442 443static void LangOptsToArgs(const LangOptions &Opts, 444 std::vector<std::string> &Res) { 445 LangOptions DefaultLangOpts; 446 447 // FIXME: Need to set -std to get all the implicit options. 448 449 // FIXME: We want to only pass options relative to the defaults, which 450 // requires constructing a target. :( 451 // 452 // It would be better to push the all target specific choices into the driver, 453 // so that everything below that was more uniform. 454 455 if (Opts.Trigraphs) 456 Res.push_back("-trigraphs"); 457 // Implicit based on the input kind: 458 // AsmPreprocessor, CPlusPlus, ObjC1, ObjC2, OpenCL 459 // Implicit based on the input language standard: 460 // BCPLComment, C99, CPlusPlus0x, Digraphs, GNUInline, ImplicitInt, GNUMode 461 if (Opts.DollarIdents) 462 Res.push_back("-fdollars-in-identifiers"); 463 if (Opts.Microsoft) 464 Res.push_back("-fms-extensions"); 465 if (Opts.ObjCNonFragileABI) 466 Res.push_back("-fobjc-nonfragile-abi"); 467 if (Opts.ObjCNonFragileABI2) 468 Res.push_back("-fobjc-nonfragile-abi2"); 469 // NoInline is implicit. 470 if (!Opts.CXXOperatorNames) 471 Res.push_back("-fno-operator-names"); 472 if (Opts.PascalStrings) 473 Res.push_back("-fpascal-strings"); 474 if (Opts.CatchUndefined) 475 Res.push_back("-fcatch-undefined-behavior"); 476 if (Opts.WritableStrings) 477 Res.push_back("-fwritable-strings"); 478 if (Opts.ConstStrings) 479 Res.push_back("-Wwrite-strings"); 480 if (!Opts.LaxVectorConversions) 481 Res.push_back("-fno-lax-vector-conversions"); 482 if (Opts.AltiVec) 483 Res.push_back("-faltivec"); 484 if (Opts.Exceptions) 485 Res.push_back("-fexceptions"); 486 if (Opts.SjLjExceptions) 487 Res.push_back("-fsjlj-exceptions"); 488 if (!Opts.RTTI) 489 Res.push_back("-fno-rtti"); 490 if (!Opts.NeXTRuntime) 491 Res.push_back("-fgnu-runtime"); 492 if (Opts.Freestanding) 493 Res.push_back("-ffreestanding"); 494 if (Opts.NoBuiltin) 495 Res.push_back("-fno-builtin"); 496 if (!Opts.AssumeSaneOperatorNew) 497 Res.push_back("-fno-assume-sane-operator-new"); 498 if (!Opts.ThreadsafeStatics) 499 Res.push_back("-fno-threadsafe-statics"); 500 if (Opts.POSIXThreads) 501 Res.push_back("-pthread"); 502 if (Opts.Blocks) 503 Res.push_back("-fblocks"); 504 if (Opts.EmitAllDecls) 505 Res.push_back("-femit-all-decls"); 506 if (Opts.MathErrno) 507 Res.push_back("-fmath-errno"); 508 if (Opts.OverflowChecking) 509 Res.push_back("-ftrapv"); 510 if (Opts.HeinousExtensions) 511 Res.push_back("-fheinous-gnu-extensions"); 512 // Optimize is implicit. 513 // OptimizeSize is implicit. 514 if (Opts.Static) 515 Res.push_back("-static-define"); 516 if (Opts.PICLevel) { 517 Res.push_back("-pic-level"); 518 Res.push_back(llvm::utostr(Opts.PICLevel)); 519 } 520 if (Opts.ObjCGCBitmapPrint) 521 Res.push_back("-print-ivar-layout"); 522 // FIXME: Don't forget to update when the default changes! 523 if (Opts.AccessControl) 524 Res.push_back("-faccess-control"); 525 if (!Opts.CharIsSigned) 526 Res.push_back("-fno-signed-char"); 527 if (Opts.ShortWChar) 528 Res.push_back("-fshort-wchar"); 529 if (!Opts.ElideConstructors) 530 Res.push_back("-fno-elide-constructors"); 531 if (Opts.getGCMode() != LangOptions::NonGC) { 532 if (Opts.getGCMode() == LangOptions::HybridGC) { 533 Res.push_back("-fobjc-gc"); 534 } else { 535 assert(Opts.getGCMode() == LangOptions::GCOnly && "Invalid GC mode!"); 536 Res.push_back("-fobjc-gc-only"); 537 } 538 } 539 if (Opts.getVisibilityMode() != LangOptions::Default) { 540 Res.push_back("-fvisibility"); 541 if (Opts.getVisibilityMode() == LangOptions::Hidden) { 542 Res.push_back("hidden"); 543 } else { 544 assert(Opts.getVisibilityMode() == LangOptions::Protected && 545 "Invalid visibility!"); 546 Res.push_back("protected"); 547 } 548 } 549 if (Opts.getStackProtectorMode() != 0) { 550 Res.push_back("-stack-protector"); 551 Res.push_back(llvm::utostr(Opts.getStackProtectorMode())); 552 } 553 if (Opts.InstantiationDepth != DefaultLangOpts.InstantiationDepth) { 554 Res.push_back("-ftemplate-depth"); 555 Res.push_back(llvm::utostr(Opts.InstantiationDepth)); 556 } 557 if (!Opts.ObjCConstantStringClass.empty()) { 558 Res.push_back("-fconstant-string-class"); 559 Res.push_back(Opts.ObjCConstantStringClass); 560 } 561} 562 563static void PreprocessorOptsToArgs(const PreprocessorOptions &Opts, 564 std::vector<std::string> &Res) { 565 for (unsigned i = 0, e = Opts.Macros.size(); i != e; ++i) 566 Res.push_back(std::string(Opts.Macros[i].second ? "-U" : "-D") + 567 Opts.Macros[i].first); 568 for (unsigned i = 0, e = Opts.Includes.size(); i != e; ++i) { 569 // FIXME: We need to avoid reincluding the implicit PCH and PTH includes. 570 Res.push_back("-include"); 571 Res.push_back(Opts.Includes[i]); 572 } 573 for (unsigned i = 0, e = Opts.MacroIncludes.size(); i != e; ++i) { 574 Res.push_back("-imacros"); 575 Res.push_back(Opts.MacroIncludes[i]); 576 } 577 if (!Opts.UsePredefines) 578 Res.push_back("-undef"); 579 if (Opts.DetailedRecord) 580 Res.push_back("-detailed-preprocessing-record"); 581 if (!Opts.ImplicitPCHInclude.empty()) { 582 Res.push_back("-include-pch"); 583 Res.push_back(Opts.ImplicitPCHInclude); 584 } 585 if (!Opts.ImplicitPTHInclude.empty()) { 586 Res.push_back("-include-pth"); 587 Res.push_back(Opts.ImplicitPTHInclude); 588 } 589 if (!Opts.TokenCache.empty()) { 590 if (Opts.ImplicitPTHInclude.empty()) { 591 Res.push_back("-token-cache"); 592 Res.push_back(Opts.TokenCache); 593 } else 594 assert(Opts.ImplicitPTHInclude == Opts.TokenCache && 595 "Unsupported option combination!"); 596 } 597 for (unsigned i = 0, e = Opts.RemappedFiles.size(); i != e; ++i) { 598 Res.push_back("-remap-file"); 599 Res.push_back(Opts.RemappedFiles[i].first + ";" + 600 Opts.RemappedFiles[i].second); 601 } 602} 603 604static void PreprocessorOutputOptsToArgs(const PreprocessorOutputOptions &Opts, 605 std::vector<std::string> &Res) { 606 if (!Opts.ShowCPP && !Opts.ShowMacros) 607 llvm::llvm_report_error("Invalid option combination!"); 608 609 if (Opts.ShowCPP && Opts.ShowMacros) 610 Res.push_back("-dD"); 611 else if (!Opts.ShowCPP && Opts.ShowMacros) 612 Res.push_back("-dM"); 613 614 if (!Opts.ShowLineMarkers) 615 Res.push_back("-P"); 616 if (Opts.ShowComments) 617 Res.push_back("-C"); 618 if (Opts.ShowMacroComments) 619 Res.push_back("-CC"); 620} 621 622static void TargetOptsToArgs(const TargetOptions &Opts, 623 std::vector<std::string> &Res) { 624 Res.push_back("-triple"); 625 Res.push_back(Opts.Triple); 626 if (!Opts.CPU.empty()) { 627 Res.push_back("-target-cpu"); 628 Res.push_back(Opts.CPU); 629 } 630 if (!Opts.ABI.empty()) { 631 Res.push_back("-target-abi"); 632 Res.push_back(Opts.ABI); 633 } 634 for (unsigned i = 0, e = Opts.Features.size(); i != e; ++i) { 635 Res.push_back("-target-feature"); 636 Res.push_back(Opts.Features[i]); 637 } 638} 639 640void CompilerInvocation::toArgs(std::vector<std::string> &Res) { 641 AnalyzerOptsToArgs(getAnalyzerOpts(), Res); 642 CodeGenOptsToArgs(getCodeGenOpts(), Res); 643 DependencyOutputOptsToArgs(getDependencyOutputOpts(), Res); 644 DiagnosticOptsToArgs(getDiagnosticOpts(), Res); 645 FrontendOptsToArgs(getFrontendOpts(), Res); 646 HeaderSearchOptsToArgs(getHeaderSearchOpts(), Res); 647 LangOptsToArgs(getLangOpts(), Res); 648 PreprocessorOptsToArgs(getPreprocessorOpts(), Res); 649 PreprocessorOutputOptsToArgs(getPreprocessorOutputOpts(), Res); 650 TargetOptsToArgs(getTargetOpts(), Res); 651} 652 653//===----------------------------------------------------------------------===// 654// Deserialization (to args) 655//===----------------------------------------------------------------------===// 656 657using namespace clang::driver; 658using namespace clang::driver::cc1options; 659 660static llvm::StringRef getLastArgValue(ArgList &Args, cc1options::ID ID, 661 llvm::StringRef Default = "") { 662 if (Arg *A = Args.getLastArg(ID)) 663 return A->getValue(Args); 664 return Default; 665} 666 667static int getLastArgIntValue(ArgList &Args, cc1options::ID ID, 668 int Default, Diagnostic &Diags) { 669 Arg *A = Args.getLastArg(ID); 670 if (!A) 671 return Default; 672 673 int Res = Default; 674 if (llvm::StringRef(A->getValue(Args)).getAsInteger(10, Res)) 675 Diags.Report(diag::err_drv_invalid_int_value) 676 << A->getAsString(Args) << A->getValue(Args); 677 678 return Res; 679} 680 681static std::vector<std::string> 682getAllArgValues(ArgList &Args, cc1options::ID ID) { 683 llvm::SmallVector<const char *, 16> Values; 684 Args.AddAllArgValues(Values, ID); 685 return std::vector<std::string>(Values.begin(), Values.end()); 686} 687 688// 689 690static void ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args, 691 Diagnostic &Diags) { 692 using namespace cc1options; 693 694 Opts.AnalysisList.clear(); 695#define ANALYSIS(NAME, CMDFLAG, DESC, SCOPE) \ 696 if (Args.hasArg(OPT_analysis_##NAME)) Opts.AnalysisList.push_back(NAME); 697#include "clang/Frontend/Analyses.def" 698 699 if (Arg *A = Args.getLastArg(OPT_analyzer_store)) { 700 llvm::StringRef Name = A->getValue(Args); 701 AnalysisStores Value = llvm::StringSwitch<AnalysisStores>(Name) 702#define ANALYSIS_STORE(NAME, CMDFLAG, DESC, CREATFN) \ 703 .Case(CMDFLAG, NAME##Model) 704#include "clang/Frontend/Analyses.def" 705 .Default(NumStores); 706 // FIXME: Error handling. 707 if (Value == NumStores) 708 Diags.Report(diag::err_drv_invalid_value) 709 << Args.getLastArg(OPT_O)->getAsString(Args) << Name; 710 else 711 Opts.AnalysisStoreOpt = Value; 712 } 713 714 if (Arg *A = Args.getLastArg(OPT_analyzer_constraints)) { 715 llvm::StringRef Name = A->getValue(Args); 716 AnalysisConstraints Value = llvm::StringSwitch<AnalysisConstraints>(Name) 717#define ANALYSIS_CONSTRAINTS(NAME, CMDFLAG, DESC, CREATFN) \ 718 .Case(CMDFLAG, NAME##Model) 719#include "clang/Frontend/Analyses.def" 720 .Default(NumConstraints); 721 // FIXME: Error handling. 722 if (Value == NumConstraints) 723 Diags.Report(diag::err_drv_invalid_value) 724 << Args.getLastArg(OPT_O)->getAsString(Args) << Name; 725 else 726 Opts.AnalysisConstraintsOpt = Value; 727 } 728 729 if (Arg *A = Args.getLastArg(OPT_analyzer_output)) { 730 llvm::StringRef Name = A->getValue(Args); 731 AnalysisDiagClients Value = llvm::StringSwitch<AnalysisDiagClients>(Name) 732#define ANALYSIS_DIAGNOSTICS(NAME, CMDFLAG, DESC, CREATFN, AUTOCREAT) \ 733 .Case(CMDFLAG, PD_##NAME) 734#include "clang/Frontend/Analyses.def" 735 .Default(NUM_ANALYSIS_DIAG_CLIENTS); 736 // FIXME: Error handling. 737 if (Value == NUM_ANALYSIS_DIAG_CLIENTS) 738 Diags.Report(diag::err_drv_invalid_value) 739 << Args.getLastArg(OPT_O)->getAsString(Args) << Name; 740 else 741 Opts.AnalysisDiagOpt = Value; 742 } 743 744 Opts.VisualizeEGDot = Args.hasArg(OPT_analyzer_viz_egraph_graphviz); 745 Opts.VisualizeEGUbi = Args.hasArg(OPT_analyzer_viz_egraph_ubigraph); 746 Opts.AnalyzeAll = Args.hasArg(OPT_analyzer_opt_analyze_headers); 747 Opts.AnalyzerDisplayProgress = Args.hasArg(OPT_analyzer_display_progress); 748 Opts.AnalyzeNestedBlocks = 749 Args.hasArg(OPT_analyzer_opt_analyze_nested_blocks); 750 Opts.PurgeDead = !Args.hasArg(OPT_analyzer_no_purge_dead); 751 Opts.EagerlyAssume = Args.hasArg(OPT_analyzer_eagerly_assume); 752 Opts.AnalyzeSpecificFunction = getLastArgValue(Args, OPT_analyze_function); 753 Opts.EnableExperimentalChecks = Args.hasArg(OPT_analyzer_experimental_checks); 754 Opts.EnableExperimentalInternalChecks = 755 Args.hasArg(OPT_analyzer_experimental_internal_checks); 756 Opts.TrimGraph = Args.hasArg(OPT_trim_egraph); 757} 758 759static void ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, 760 Diagnostic &Diags) { 761 using namespace cc1options; 762 // -Os implies -O2 763 if (Args.hasArg(OPT_Os)) 764 Opts.OptimizationLevel = 2; 765 else { 766 Opts.OptimizationLevel = getLastArgIntValue(Args, OPT_O, 0, Diags); 767 if (Opts.OptimizationLevel > 3) { 768 Diags.Report(diag::err_drv_invalid_value) 769 << Args.getLastArg(OPT_O)->getAsString(Args) << Opts.OptimizationLevel; 770 Opts.OptimizationLevel = 3; 771 } 772 } 773 774 // We must always run at least the always inlining pass. 775 Opts.Inlining = (Opts.OptimizationLevel > 1) ? CodeGenOptions::NormalInlining 776 : CodeGenOptions::OnlyAlwaysInlining; 777 778 Opts.DebugInfo = Args.hasArg(OPT_g); 779 Opts.DisableLLVMOpts = Args.hasArg(OPT_disable_llvm_optzns); 780 Opts.DisableRedZone = Args.hasArg(OPT_disable_red_zone); 781 Opts.DwarfDebugFlags = getLastArgValue(Args, OPT_dwarf_debug_flags); 782 Opts.MergeAllConstants = !Args.hasArg(OPT_fno_merge_all_constants); 783 Opts.NoCommon = Args.hasArg(OPT_fno_common); 784 Opts.NoImplicitFloat = Args.hasArg(OPT_no_implicit_float); 785 Opts.OptimizeSize = Args.hasArg(OPT_Os); 786 Opts.UnrollLoops = (Opts.OptimizationLevel > 1 && !Opts.OptimizeSize); 787 788 Opts.AsmVerbose = Args.hasArg(OPT_masm_verbose); 789 Opts.CXAAtExit = !Args.hasArg(OPT_fno_use_cxa_atexit); 790 Opts.CXXCtorDtorAliases = Args.hasArg(OPT_mconstructor_aliases); 791 Opts.CodeModel = getLastArgValue(Args, OPT_mcode_model); 792 Opts.DebugPass = getLastArgValue(Args, OPT_mdebug_pass); 793 Opts.DisableFPElim = Args.hasArg(OPT_mdisable_fp_elim); 794 Opts.FloatABI = getLastArgValue(Args, OPT_mfloat_abi); 795 Opts.LimitFloatPrecision = getLastArgValue(Args, OPT_mlimit_float_precision); 796 Opts.NoZeroInitializedInBSS = Args.hasArg(OPT_mno_zero_initialized_in_bss); 797 Opts.ObjCLegacyDispatch = Args.hasArg(OPT_fobjc_legacy_dispatch); 798 Opts.SoftFloat = Args.hasArg(OPT_msoft_float); 799 Opts.UnwindTables = Args.hasArg(OPT_munwind_tables); 800 Opts.RelocationModel = getLastArgValue(Args, OPT_mrelocation_model, "pic"); 801 802 Opts.MainFileName = getLastArgValue(Args, OPT_main_file_name); 803 Opts.VerifyModule = !Args.hasArg(OPT_disable_llvm_verifier); 804} 805 806static void ParseDependencyOutputArgs(DependencyOutputOptions &Opts, 807 ArgList &Args) { 808 using namespace cc1options; 809 Opts.OutputFile = getLastArgValue(Args, OPT_dependency_file); 810 Opts.Targets = getAllArgValues(Args, OPT_MT); 811 Opts.IncludeSystemHeaders = Args.hasArg(OPT_sys_header_deps); 812 Opts.UsePhonyTargets = Args.hasArg(OPT_MP); 813} 814 815static void ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args, 816 Diagnostic &Diags) { 817 using namespace cc1options; 818 Opts.IgnoreWarnings = Args.hasArg(OPT_w); 819 Opts.NoRewriteMacros = Args.hasArg(OPT_Wno_rewrite_macros); 820 Opts.Pedantic = Args.hasArg(OPT_pedantic); 821 Opts.PedanticErrors = Args.hasArg(OPT_pedantic_errors); 822 Opts.ShowCarets = !Args.hasArg(OPT_fno_caret_diagnostics); 823 Opts.ShowColors = Args.hasArg(OPT_fcolor_diagnostics); 824 Opts.ShowColumn = !Args.hasArg(OPT_fno_show_column); 825 Opts.ShowFixits = !Args.hasArg(OPT_fno_diagnostics_fixit_info); 826 Opts.ShowLocation = !Args.hasArg(OPT_fno_show_source_location); 827 Opts.ShowOptionNames = Args.hasArg(OPT_fdiagnostics_show_option); 828 Opts.ShowSourceRanges = Args.hasArg(OPT_fdiagnostics_print_source_range_info); 829 Opts.VerifyDiagnostics = Args.hasArg(OPT_verify); 830 Opts.BinaryOutput = Args.hasArg(OPT_fdiagnostics_binary); 831 Opts.TabStop = getLastArgIntValue(Args, OPT_ftabstop, 832 DiagnosticOptions::DefaultTabStop, Diags); 833 if (Opts.TabStop == 0 || Opts.TabStop > DiagnosticOptions::MaxTabStop) { 834 Diags.Report(diag::warn_ignoring_ftabstop_value) 835 << Opts.TabStop << DiagnosticOptions::DefaultTabStop; 836 Opts.TabStop = DiagnosticOptions::DefaultTabStop; 837 } 838 Opts.MessageLength = getLastArgIntValue(Args, OPT_fmessage_length, 0, Diags); 839 Opts.DumpBuildInformation = getLastArgValue(Args, OPT_dump_build_information); 840 Opts.Warnings = getAllArgValues(Args, OPT_W); 841} 842 843static FrontendOptions::InputKind 844ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, Diagnostic &Diags) { 845 using namespace cc1options; 846 Opts.ProgramAction = frontend::ParseSyntaxOnly; 847 if (const Arg *A = Args.getLastArg(OPT_Action_Group)) { 848 switch (A->getOption().getID()) { 849 default: 850 assert(0 && "Invalid option in group!"); 851 case OPT_ast_dump: 852 Opts.ProgramAction = frontend::ASTDump; break; 853 case OPT_ast_print: 854 Opts.ProgramAction = frontend::ASTPrint; break; 855 case OPT_ast_print_xml: 856 Opts.ProgramAction = frontend::ASTPrintXML; break; 857 case OPT_ast_view: 858 Opts.ProgramAction = frontend::ASTView; break; 859 case OPT_dump_raw_tokens: 860 Opts.ProgramAction = frontend::DumpRawTokens; break; 861 case OPT_dump_record_layouts: 862 Opts.ProgramAction = frontend::DumpRecordLayouts; break; 863 case OPT_dump_tokens: 864 Opts.ProgramAction = frontend::DumpTokens; break; 865 case OPT_S: 866 Opts.ProgramAction = frontend::EmitAssembly; break; 867 case OPT_emit_llvm_bc: 868 Opts.ProgramAction = frontend::EmitBC; break; 869 case OPT_emit_html: 870 Opts.ProgramAction = frontend::EmitHTML; break; 871 case OPT_emit_llvm: 872 Opts.ProgramAction = frontend::EmitLLVM; break; 873 case OPT_emit_llvm_only: 874 Opts.ProgramAction = frontend::EmitLLVMOnly; break; 875 case OPT_emit_obj: 876 Opts.ProgramAction = frontend::EmitObj; break; 877 case OPT_fixit: 878 Opts.ProgramAction = frontend::FixIt; break; 879 case OPT_emit_pch: 880 Opts.ProgramAction = frontend::GeneratePCH; break; 881 case OPT_emit_pth: 882 Opts.ProgramAction = frontend::GeneratePTH; break; 883 case OPT_init_only: 884 Opts.ProgramAction = frontend::InitOnly; break; 885 case OPT_parse_noop: 886 Opts.ProgramAction = frontend::ParseNoop; break; 887 case OPT_parse_print_callbacks: 888 Opts.ProgramAction = frontend::ParsePrintCallbacks; break; 889 case OPT_fsyntax_only: 890 Opts.ProgramAction = frontend::ParseSyntaxOnly; break; 891 case OPT_print_decl_contexts: 892 Opts.ProgramAction = frontend::PrintDeclContext; break; 893 case OPT_E: 894 Opts.ProgramAction = frontend::PrintPreprocessedInput; break; 895 case OPT_rewrite_macros: 896 Opts.ProgramAction = frontend::RewriteMacros; break; 897 case OPT_rewrite_objc: 898 Opts.ProgramAction = frontend::RewriteObjC; break; 899 case OPT_rewrite_test: 900 Opts.ProgramAction = frontend::RewriteTest; break; 901 case OPT_analyze: 902 Opts.ProgramAction = frontend::RunAnalysis; break; 903 case OPT_Eonly: 904 Opts.ProgramAction = frontend::RunPreprocessorOnly; break; 905 } 906 } 907 if (const Arg *A = Args.getLastArg(OPT_plugin)) { 908 Opts.ProgramAction = frontend::PluginAction; 909 Opts.ActionName = A->getValue(Args); 910 } 911 912 if (const Arg *A = Args.getLastArg(OPT_code_completion_at)) { 913 Opts.CodeCompletionAt = 914 ParsedSourceLocation::FromString(A->getValue(Args)); 915 if (Opts.CodeCompletionAt.FileName.empty()) 916 Diags.Report(diag::err_drv_invalid_value) 917 << A->getAsString(Args) << A->getValue(Args); 918 } 919 Opts.DebugCodeCompletionPrinter = 920 !Args.hasArg(OPT_no_code_completion_debug_printer); 921 Opts.DisableFree = Args.hasArg(OPT_disable_free); 922 923 Opts.FixItLocations.clear(); 924 for (arg_iterator it = Args.filtered_begin(OPT_fixit_at), 925 ie = Args.filtered_end(); it != ie; ++it) { 926 const char *Loc = it->getValue(Args); 927 ParsedSourceLocation PSL = ParsedSourceLocation::FromString(Loc); 928 929 if (PSL.FileName.empty()) { 930 Diags.Report(diag::err_drv_invalid_value) << it->getAsString(Args) << Loc; 931 continue; 932 } 933 934 Opts.FixItLocations.push_back(PSL); 935 } 936 937 Opts.OutputFile = getLastArgValue(Args, OPT_o); 938 Opts.Plugins = getAllArgValues(Args, OPT_load); 939 Opts.RelocatablePCH = Args.hasArg(OPT_relocatable_pch); 940 Opts.ShowHelp = Args.hasArg(OPT_help); 941 Opts.ShowMacrosInCodeCompletion = Args.hasArg(OPT_code_completion_macros); 942 Opts.ShowStats = Args.hasArg(OPT_print_stats); 943 Opts.ShowTimers = Args.hasArg(OPT_ftime_report); 944 Opts.ShowVersion = Args.hasArg(OPT_version); 945 Opts.ViewClassInheritance = getLastArgValue(Args, OPT_cxx_inheritance_view); 946 Opts.ASTMergeFiles = getAllArgValues(Args, OPT_ast_merge); 947 948 FrontendOptions::InputKind DashX = FrontendOptions::IK_None; 949 if (const Arg *A = Args.getLastArg(OPT_x)) { 950 DashX = llvm::StringSwitch<FrontendOptions::InputKind>(A->getValue(Args)) 951 .Case("c", FrontendOptions::IK_C) 952 .Case("cl", FrontendOptions::IK_OpenCL) 953 .Case("c", FrontendOptions::IK_C) 954 .Case("cl", FrontendOptions::IK_OpenCL) 955 .Case("c++", FrontendOptions::IK_CXX) 956 .Case("objective-c", FrontendOptions::IK_ObjC) 957 .Case("objective-c++", FrontendOptions::IK_ObjCXX) 958 .Case("cpp-output", FrontendOptions::IK_PreprocessedC) 959 .Case("assembler-with-cpp", FrontendOptions::IK_Asm) 960 .Case("c++-cpp-output", FrontendOptions::IK_PreprocessedCXX) 961 .Case("objective-c-cpp-output", FrontendOptions::IK_PreprocessedObjC) 962 .Case("objective-c++-cpp-output", FrontendOptions::IK_PreprocessedObjCXX) 963 .Case("c-header", FrontendOptions::IK_C) 964 .Case("objective-c-header", FrontendOptions::IK_ObjC) 965 .Case("c++-header", FrontendOptions::IK_CXX) 966 .Case("objective-c++-header", FrontendOptions::IK_ObjCXX) 967 .Case("ast", FrontendOptions::IK_AST) 968 .Default(FrontendOptions::IK_None); 969 if (DashX == FrontendOptions::IK_None) 970 Diags.Report(diag::err_drv_invalid_value) 971 << A->getAsString(Args) << A->getValue(Args); 972 } 973 974 // '-' is the default input if none is given. 975 std::vector<std::string> Inputs = getAllArgValues(Args, OPT_INPUT); 976 Opts.Inputs.clear(); 977 if (Inputs.empty()) 978 Inputs.push_back("-"); 979 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) { 980 FrontendOptions::InputKind IK = DashX; 981 if (IK == FrontendOptions::IK_None) { 982 IK = FrontendOptions::getInputKindForExtension( 983 llvm::StringRef(Inputs[i]).rsplit('.').second); 984 // FIXME: Remove this hack. 985 if (i == 0) 986 DashX = IK; 987 } 988 Opts.Inputs.push_back(std::make_pair(IK, Inputs[i])); 989 } 990 991 return DashX; 992} 993 994std::string CompilerInvocation::GetResourcesPath(const char *Argv0, 995 void *MainAddr) { 996 llvm::sys::Path P = llvm::sys::Path::GetMainExecutable(Argv0, MainAddr); 997 998 if (!P.isEmpty()) { 999 P.eraseComponent(); // Remove /clang from foo/bin/clang 1000 P.eraseComponent(); // Remove /bin from foo/bin 1001 1002 // Get foo/lib/clang/<version>/include 1003 P.appendComponent("lib"); 1004 P.appendComponent("clang"); 1005 P.appendComponent(CLANG_VERSION_STRING); 1006 } 1007 1008 return P.str(); 1009} 1010 1011static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) { 1012 using namespace cc1options; 1013 Opts.Sysroot = getLastArgValue(Args, OPT_isysroot, "/"); 1014 Opts.Verbose = Args.hasArg(OPT_v); 1015 Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc); 1016 Opts.UseStandardIncludes = !Args.hasArg(OPT_nostdinc); 1017 Opts.ResourceDir = getLastArgValue(Args, OPT_resource_dir); 1018 1019 // Add -I... and -F... options in order. 1020 for (arg_iterator it = Args.filtered_begin(OPT_I, OPT_F), 1021 ie = Args.filtered_end(); it != ie; ++it) 1022 Opts.AddPath(it->getValue(Args), frontend::Angled, true, 1023 /*IsFramework=*/ it->getOption().matches(OPT_F)); 1024 1025 // Add -iprefix/-iwith-prefix/-iwithprefixbefore options. 1026 llvm::StringRef Prefix = ""; // FIXME: This isn't the correct default prefix. 1027 for (arg_iterator it = Args.filtered_begin(OPT_iprefix, OPT_iwithprefix, 1028 OPT_iwithprefixbefore), 1029 ie = Args.filtered_end(); it != ie; ++it) { 1030 if (it->getOption().matches(OPT_iprefix)) 1031 Prefix = it->getValue(Args); 1032 else if (it->getOption().matches(OPT_iwithprefix)) 1033 Opts.AddPath(Prefix.str() + it->getValue(Args), 1034 frontend::System, false, false); 1035 else 1036 Opts.AddPath(Prefix.str() + it->getValue(Args), 1037 frontend::Angled, false, false); 1038 } 1039 1040 for (arg_iterator it = Args.filtered_begin(OPT_idirafter), 1041 ie = Args.filtered_end(); it != ie; ++it) 1042 Opts.AddPath(it->getValue(Args), frontend::After, true, false); 1043 for (arg_iterator it = Args.filtered_begin(OPT_iquote), 1044 ie = Args.filtered_end(); it != ie; ++it) 1045 Opts.AddPath(it->getValue(Args), frontend::Quoted, true, false); 1046 for (arg_iterator it = Args.filtered_begin(OPT_isystem), 1047 ie = Args.filtered_end(); it != ie; ++it) 1048 Opts.AddPath(it->getValue(Args), frontend::System, true, false); 1049 1050 // FIXME: Need options for the various environment variables! 1051} 1052 1053static void ParseLangArgs(LangOptions &Opts, ArgList &Args, 1054 FrontendOptions::InputKind IK, 1055 Diagnostic &Diags) { 1056 // FIXME: Cleanup per-file based stuff. 1057 1058 // Set some properties which depend soley on the input kind; it would be nice 1059 // to move these to the language standard, and have the driver resolve the 1060 // input kind + language standard. 1061 if (IK == FrontendOptions::IK_Asm) { 1062 Opts.AsmPreprocessor = 1; 1063 } else if (IK == FrontendOptions::IK_ObjC || 1064 IK == FrontendOptions::IK_ObjCXX || 1065 IK == FrontendOptions::IK_PreprocessedObjC || 1066 IK == FrontendOptions::IK_PreprocessedObjCXX) { 1067 Opts.ObjC1 = Opts.ObjC2 = 1; 1068 } 1069 1070 LangStandard::Kind LangStd = LangStandard::lang_unspecified; 1071 if (const Arg *A = Args.getLastArg(OPT_std_EQ)) { 1072 LangStd = llvm::StringSwitch<LangStandard::Kind>(A->getValue(Args)) 1073#define LANGSTANDARD(id, name, desc, features) \ 1074 .Case(name, LangStandard::lang_##id) 1075#include "clang/Frontend/LangStandards.def" 1076 .Default(LangStandard::lang_unspecified); 1077 if (LangStd == LangStandard::lang_unspecified) 1078 Diags.Report(diag::err_drv_invalid_value) 1079 << A->getAsString(Args) << A->getValue(Args); 1080 } 1081 1082 if (LangStd == LangStandard::lang_unspecified) { 1083 // Based on the base language, pick one. 1084 switch (IK) { 1085 case FrontendOptions::IK_None: 1086 case FrontendOptions::IK_AST: 1087 assert(0 && "Invalid input kind!"); 1088 case FrontendOptions::IK_OpenCL: 1089 LangStd = LangStandard::lang_opencl; 1090 break; 1091 case FrontendOptions::IK_Asm: 1092 case FrontendOptions::IK_C: 1093 case FrontendOptions::IK_PreprocessedC: 1094 case FrontendOptions::IK_ObjC: 1095 case FrontendOptions::IK_PreprocessedObjC: 1096 LangStd = LangStandard::lang_gnu99; 1097 break; 1098 case FrontendOptions::IK_CXX: 1099 case FrontendOptions::IK_PreprocessedCXX: 1100 case FrontendOptions::IK_ObjCXX: 1101 case FrontendOptions::IK_PreprocessedObjCXX: 1102 LangStd = LangStandard::lang_gnucxx98; 1103 break; 1104 } 1105 } 1106 1107 const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd); 1108 Opts.BCPLComment = Std.hasBCPLComments(); 1109 Opts.C99 = Std.isC99(); 1110 Opts.CPlusPlus = Std.isCPlusPlus(); 1111 Opts.CPlusPlus0x = Std.isCPlusPlus0x(); 1112 Opts.Digraphs = Std.hasDigraphs(); 1113 Opts.GNUMode = Std.isGNUMode(); 1114 Opts.GNUInline = !Std.isC99(); 1115 Opts.HexFloats = Std.hasHexFloats(); 1116 Opts.ImplicitInt = Std.hasImplicitInt(); 1117 1118 // OpenCL has some additional defaults. 1119 if (LangStd == LangStandard::lang_opencl) { 1120 Opts.OpenCL = 1; 1121 Opts.AltiVec = 1; 1122 Opts.CXXOperatorNames = 1; 1123 Opts.LaxVectorConversions = 1; 1124 } 1125 1126 // OpenCL and C++ both have bool, true, false keywords. 1127 Opts.Bool = Opts.OpenCL || Opts.CPlusPlus; 1128 1129 if (Opts.CPlusPlus) 1130 Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names); 1131 1132 if (Args.hasArg(OPT_fobjc_gc_only)) 1133 Opts.setGCMode(LangOptions::GCOnly); 1134 else if (Args.hasArg(OPT_fobjc_gc)) 1135 Opts.setGCMode(LangOptions::HybridGC); 1136 1137 if (Args.hasArg(OPT_print_ivar_layout)) 1138 Opts.ObjCGCBitmapPrint = 1; 1139 1140 if (Args.hasArg(OPT_faltivec)) 1141 Opts.AltiVec = 1; 1142 1143 if (Args.hasArg(OPT_pthread)) 1144 Opts.POSIXThreads = 1; 1145 1146 llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility, 1147 "default"); 1148 if (Vis == "default") 1149 Opts.setVisibilityMode(LangOptions::Default); 1150 else if (Vis == "hidden") 1151 Opts.setVisibilityMode(LangOptions::Hidden); 1152 else if (Vis == "protected") 1153 Opts.setVisibilityMode(LangOptions::Protected); 1154 else 1155 Diags.Report(diag::err_drv_invalid_value) 1156 << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis; 1157 1158 Opts.OverflowChecking = Args.hasArg(OPT_ftrapv); 1159 1160 // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs 1161 // is specified, or -std is set to a conforming mode. 1162 Opts.Trigraphs = !Opts.GNUMode; 1163 if (Args.hasArg(OPT_trigraphs)) 1164 Opts.Trigraphs = 1; 1165 1166 Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers, 1167 OPT_fno_dollars_in_identifiers, 1168 !Opts.AsmPreprocessor); 1169 Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings); 1170 Opts.Microsoft = Args.hasArg(OPT_fms_extensions); 1171 Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings); 1172 Opts.ConstStrings = Args.hasArg(OPT_Wwrite_strings); 1173 if (Args.hasArg(OPT_fno_lax_vector_conversions)) 1174 Opts.LaxVectorConversions = 0; 1175 if (Args.hasArg(OPT_fno_threadsafe_statics)) 1176 Opts.ThreadsafeStatics = 0; 1177 Opts.Exceptions = Args.hasArg(OPT_fexceptions); 1178 Opts.RTTI = !Args.hasArg(OPT_fno_rtti); 1179 Opts.Blocks = Args.hasArg(OPT_fblocks); 1180 Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char); 1181 Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar); 1182 Opts.Freestanding = Args.hasArg(OPT_ffreestanding); 1183 Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding; 1184 Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new); 1185 Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions); 1186 Opts.AccessControl = Args.hasArg(OPT_faccess_control); 1187 Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors); 1188 Opts.MathErrno = Args.hasArg(OPT_fmath_errno); 1189 Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99, 1190 Diags); 1191 Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime); 1192 Opts.ObjCConstantStringClass = getLastArgValue(Args, 1193 OPT_fconstant_string_class); 1194 Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi); 1195 Opts.ObjCNonFragileABI2 = Args.hasArg(OPT_fobjc_nonfragile_abi2); 1196 if (Opts.ObjCNonFragileABI2) 1197 Opts.ObjCNonFragileABI = true; 1198 Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior); 1199 Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls); 1200 Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags); 1201 Opts.SjLjExceptions = Args.hasArg(OPT_fsjlj_exceptions); 1202 Opts.Static = Args.hasArg(OPT_static_define); 1203 Opts.DumpVtableLayouts = Args.hasArg(OPT_fdump_vtable_layouts); 1204 Opts.OptimizeSize = 0; 1205 1206 // FIXME: Eliminate this dependency. 1207 unsigned Opt = 1208 Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags); 1209 Opts.Optimize = Opt != 0; 1210 1211 // This is the __NO_INLINE__ define, which just depends on things like the 1212 // optimization level and -fno-inline, not actually whether the backend has 1213 // inlining enabled. 1214 // 1215 // FIXME: This is affected by other options (-fno-inline). 1216 Opts.NoInline = !Opt; 1217 1218 unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags); 1219 switch (SSP) { 1220 default: 1221 Diags.Report(diag::err_drv_invalid_value) 1222 << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP; 1223 break; 1224 case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break; 1225 case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break; 1226 case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break; 1227 } 1228} 1229 1230static void ParsePreprocessorArgs(PreprocessorOptions &Opts, ArgList &Args, 1231 Diagnostic &Diags) { 1232 using namespace cc1options; 1233 Opts.ImplicitPCHInclude = getLastArgValue(Args, OPT_include_pch); 1234 Opts.ImplicitPTHInclude = getLastArgValue(Args, OPT_include_pth); 1235 if (const Arg *A = Args.getLastArg(OPT_token_cache)) 1236 Opts.TokenCache = A->getValue(Args); 1237 else 1238 Opts.TokenCache = Opts.ImplicitPTHInclude; 1239 Opts.UsePredefines = !Args.hasArg(OPT_undef); 1240 Opts.DetailedRecord = Args.hasArg(OPT_detailed_preprocessing_record); 1241 // Add macros from the command line. 1242 for (arg_iterator it = Args.filtered_begin(OPT_D, OPT_U), 1243 ie = Args.filtered_end(); it != ie; ++it) { 1244 if (it->getOption().matches(OPT_D)) 1245 Opts.addMacroDef(it->getValue(Args)); 1246 else 1247 Opts.addMacroUndef(it->getValue(Args)); 1248 } 1249 1250 Opts.MacroIncludes = getAllArgValues(Args, OPT_imacros); 1251 1252 // Add the ordered list of -includes. 1253 for (arg_iterator it = Args.filtered_begin(OPT_include, OPT_include_pch, 1254 OPT_include_pth), 1255 ie = Args.filtered_end(); it != ie; ++it) { 1256 // PCH is handled specially, we need to extra the original include path. 1257 if (it->getOption().matches(OPT_include_pch)) { 1258 std::string OriginalFile = 1259 PCHReader::getOriginalSourceFile(it->getValue(Args), Diags); 1260 if (OriginalFile.empty()) 1261 continue; 1262 1263 Opts.Includes.push_back(OriginalFile); 1264 } else 1265 Opts.Includes.push_back(it->getValue(Args)); 1266 } 1267 1268 for (arg_iterator it = Args.filtered_begin(OPT_remap_file), 1269 ie = Args.filtered_end(); it != ie; ++it) { 1270 std::pair<llvm::StringRef,llvm::StringRef> Split = 1271 llvm::StringRef(it->getValue(Args)).split(';'); 1272 1273 if (Split.second.empty()) { 1274 Diags.Report(diag::err_drv_invalid_remap_file) << it->getAsString(Args); 1275 continue; 1276 } 1277 1278 Opts.addRemappedFile(Split.first, Split.second); 1279 } 1280} 1281 1282static void ParsePreprocessorOutputArgs(PreprocessorOutputOptions &Opts, 1283 ArgList &Args) { 1284 using namespace cc1options; 1285 Opts.ShowCPP = !Args.hasArg(OPT_dM); 1286 Opts.ShowMacros = Args.hasArg(OPT_dM) || Args.hasArg(OPT_dD); 1287 Opts.ShowLineMarkers = !Args.hasArg(OPT_P); 1288 Opts.ShowComments = Args.hasArg(OPT_C); 1289 Opts.ShowMacroComments = Args.hasArg(OPT_CC); 1290} 1291 1292static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args) { 1293 using namespace cc1options; 1294 Opts.ABI = getLastArgValue(Args, OPT_target_abi); 1295 Opts.CPU = getLastArgValue(Args, OPT_target_cpu); 1296 Opts.Triple = getLastArgValue(Args, OPT_triple); 1297 Opts.Features = getAllArgValues(Args, OPT_target_feature); 1298 1299 // Use the host triple if unspecified. 1300 if (Opts.Triple.empty()) 1301 Opts.Triple = llvm::sys::getHostTriple(); 1302} 1303 1304// 1305 1306void CompilerInvocation::CreateFromArgs(CompilerInvocation &Res, 1307 const char **ArgBegin, 1308 const char **ArgEnd, 1309 Diagnostic &Diags) { 1310 // Parse the arguments. 1311 llvm::OwningPtr<OptTable> Opts(createCC1OptTable()); 1312 unsigned MissingArgIndex, MissingArgCount; 1313 llvm::OwningPtr<InputArgList> Args( 1314 Opts->ParseArgs(ArgBegin, ArgEnd,MissingArgIndex, MissingArgCount)); 1315 1316 // Check for missing argument error. 1317 if (MissingArgCount) 1318 Diags.Report(diag::err_drv_missing_argument) 1319 << Args->getArgString(MissingArgIndex) << MissingArgCount; 1320 1321 // Issue errors on unknown arguments. 1322 for (arg_iterator it = Args->filtered_begin(OPT_UNKNOWN), 1323 ie = Args->filtered_end(); it != ie; ++it) 1324 Diags.Report(diag::err_drv_unknown_argument) << it->getAsString(*Args); 1325 1326 ParseAnalyzerArgs(Res.getAnalyzerOpts(), *Args, Diags); 1327 ParseCodeGenArgs(Res.getCodeGenOpts(), *Args, Diags); 1328 ParseDependencyOutputArgs(Res.getDependencyOutputOpts(), *Args); 1329 ParseDiagnosticArgs(Res.getDiagnosticOpts(), *Args, Diags); 1330 FrontendOptions::InputKind DashX = 1331 ParseFrontendArgs(Res.getFrontendOpts(), *Args, Diags); 1332 ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), *Args); 1333 if (DashX != FrontendOptions::IK_AST) 1334 ParseLangArgs(Res.getLangOpts(), *Args, DashX, Diags); 1335 ParsePreprocessorArgs(Res.getPreprocessorOpts(), *Args, Diags); 1336 ParsePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), *Args); 1337 ParseTargetArgs(Res.getTargetOpts(), *Args); 1338} 1339