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