llvm::opt::DerivedArgList * HIPToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch, Action::OffloadKind DeviceOffloadKind) const { DerivedArgList *DAL = HostTC.TranslateArgs(Args, BoundArch, DeviceOffloadKind); if (!DAL) DAL = new DerivedArgList(Args.getBaseArgs()); const OptTable &Opts = getDriver().getOpts(); for (Arg *A : Args) { if (A->getOption().matches(options::OPT_Xarch__)) { // Skip this argument unless the architecture matches BoundArch. if (BoundArch.empty() || A->getValue(0) != BoundArch) continue; unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1)); unsigned Prev = Index; std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index)); // If the argument parsing failed or more than one argument was // consumed, the -Xarch_ argument's parameter tried to consume // extra arguments. Emit an error and ignore. // // We also want to disallow any options which would alter the // driver behavior; that isn't going to work in our model. We // use isDriverOption() as an approximation, although things // like -O4 are going to slip through. if (!XarchArg || Index > Prev + 1) { getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args) << A->getAsString(Args); continue; } else if (XarchArg->getOption().hasFlag(options::DriverOption)) { getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver) << A->getAsString(Args); continue; } XarchArg->setBaseArg(A); A = XarchArg.release(); DAL->AddSynthesizedArg(A); } DAL->append(A); } if (!BoundArch.empty()) { DAL->eraseArg(options::OPT_march_EQ); DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ), BoundArch); } return DAL; }
llvm::opt::DerivedArgList * MSVCToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args, const char *BoundArch) const { DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); const OptTable &Opts = getDriver().getOpts(); // /Oy and /Oy- only has an effect under X86-32. bool SupportsForcingFramePointer = getArch() == llvm::Triple::x86; // The -O[12xd] flag actually expands to several flags. We must desugar the // flags so that options embedded can be negated. For example, the '-O2' flag // enables '-Oy'. Expanding '-O2' into its constituent flags allows us to // correctly handle '-O2 -Oy-' where the trailing '-Oy-' disables a single // aspect of '-O2'. // // Note that this expansion logic only applies to the *last* of '[12xd]'. // First step is to search for the character we'd like to expand. const char *ExpandChar = nullptr; for (Arg *A : Args) { if (!A->getOption().matches(options::OPT__SLASH_O)) continue; StringRef OptStr = A->getValue(); for (size_t I = 0, E = OptStr.size(); I != E; ++I) { char OptChar = OptStr[I]; char PrevChar = I > 0 ? OptStr[I - 1] : '0'; if (PrevChar == 'b') { // OptChar does not expand; it's an argument to the previous char. continue; } if (OptChar == '1' || OptChar == '2' || OptChar == 'x' || OptChar == 'd') ExpandChar = OptStr.data() + I; } } for (Arg *A : Args) { if (A->getOption().matches(options::OPT__SLASH_O)) { // The -O flag actually takes an amalgam of other options. For example, // '/Ogyb2' is equivalent to '/Og' '/Oy' '/Ob2'. TranslateOptArg(A, *DAL, SupportsForcingFramePointer, ExpandChar, Opts); } else if (A->getOption().matches(options::OPT_D)) { // Translate -Dfoo#bar into -Dfoo=bar. TranslateDArg(A, *DAL, Opts); } else { DAL->append(A); } } return DAL; }
llvm::opt::DerivedArgList * CudaToolChain::TranslateArgs(const llvm::opt::DerivedArgList &Args, StringRef BoundArch, Action::OffloadKind DeviceOffloadKind) const { DerivedArgList *DAL = HostTC.TranslateArgs(Args, BoundArch, DeviceOffloadKind); if (!DAL) DAL = new DerivedArgList(Args.getBaseArgs()); const OptTable &Opts = getDriver().getOpts(); // For OpenMP device offloading, append derived arguments. Make sure // flags are not duplicated. // Also append the compute capability. if (DeviceOffloadKind == Action::OFK_OpenMP) { for (Arg *A : Args) { bool IsDuplicate = false; for (Arg *DALArg : *DAL) { if (A == DALArg) { IsDuplicate = true; break; } } if (!IsDuplicate) DAL->append(A); } StringRef Arch = DAL->getLastArgValue(options::OPT_march_EQ); if (Arch.empty()) DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ), CLANG_OPENMP_NVPTX_DEFAULT_ARCH); return DAL; } for (Arg *A : Args) { if (A->getOption().matches(options::OPT_Xarch__)) { // Skip this argument unless the architecture matches BoundArch if (BoundArch.empty() || A->getValue(0) != BoundArch) continue; unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(1)); unsigned Prev = Index; std::unique_ptr<Arg> XarchArg(Opts.ParseOneArg(Args, Index)); // If the argument parsing failed or more than one argument was // consumed, the -Xarch_ argument's parameter tried to consume // extra arguments. Emit an error and ignore. // // We also want to disallow any options which would alter the // driver behavior; that isn't going to work in our model. We // use isDriverOption() as an approximation, although things // like -O4 are going to slip through. if (!XarchArg || Index > Prev + 1) { getDriver().Diag(diag::err_drv_invalid_Xarch_argument_with_args) << A->getAsString(Args); continue; } else if (XarchArg->getOption().hasFlag(options::DriverOption)) { getDriver().Diag(diag::err_drv_invalid_Xarch_argument_isdriver) << A->getAsString(Args); continue; } XarchArg->setBaseArg(A); A = XarchArg.release(); DAL->AddSynthesizedArg(A); } DAL->append(A); } if (!BoundArch.empty()) { DAL->eraseArg(options::OPT_march_EQ); DAL->AddJoinedArg(nullptr, Opts.getOption(options::OPT_march_EQ), BoundArch); } return DAL; }
llvm::opt::DerivedArgList *ToolChain::TranslateOpenMPTargetArgs( const llvm::opt::DerivedArgList &Args, bool SameTripleAsHost, SmallVectorImpl<llvm::opt::Arg *> &AllocatedArgs) const { DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); const OptTable &Opts = getDriver().getOpts(); bool Modified = false; // Handle -Xopenmp-target flags for (auto *A : Args) { // Exclude flags which may only apply to the host toolchain. // Do not exclude flags when the host triple (AuxTriple) // matches the current toolchain triple. If it is not present // at all, target and host share a toolchain. if (A->getOption().matches(options::OPT_m_Group)) { if (SameTripleAsHost) DAL->append(A); else Modified = true; continue; } unsigned Index; unsigned Prev; bool XOpenMPTargetNoTriple = A->getOption().matches(options::OPT_Xopenmp_target); if (A->getOption().matches(options::OPT_Xopenmp_target_EQ)) { // Passing device args: -Xopenmp-target=<triple> -opt=val. if (A->getValue(0) == getTripleString()) Index = Args.getBaseArgs().MakeIndex(A->getValue(1)); else continue; } else if (XOpenMPTargetNoTriple) { // Passing device args: -Xopenmp-target -opt=val. Index = Args.getBaseArgs().MakeIndex(A->getValue(0)); } else { DAL->append(A); continue; } // Parse the argument to -Xopenmp-target. Prev = Index; std::unique_ptr<Arg> XOpenMPTargetArg(Opts.ParseOneArg(Args, Index)); if (!XOpenMPTargetArg || Index > Prev + 1) { getDriver().Diag(diag::err_drv_invalid_Xopenmp_target_with_args) << A->getAsString(Args); continue; } if (XOpenMPTargetNoTriple && XOpenMPTargetArg && Args.getAllArgValues(options::OPT_fopenmp_targets_EQ).size() != 1) { getDriver().Diag(diag::err_drv_Xopenmp_target_missing_triple); continue; } XOpenMPTargetArg->setBaseArg(A); A = XOpenMPTargetArg.release(); AllocatedArgs.push_back(A); DAL->append(A); Modified = true; } if (Modified) return DAL; delete DAL; return nullptr; }
DerivedArgList *Darwin::TranslateArgs(InputArgList &Args, const char *BoundArch) const { DerivedArgList *DAL = new DerivedArgList(Args, false); const OptTable &Opts = getDriver().getOpts(); // FIXME: We really want to get out of the tool chain level argument // translation business, as it makes the driver functionality much // more opaque. For now, we follow gcc closely solely for the // purpose of easily achieving feature parity & testability. Once we // have something that works, we should reevaluate each translation // and try to push it down into tool specific logic. Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ); Arg *iPhoneVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ); if (OSXVersion && iPhoneVersion) { getDriver().Diag(clang::diag::err_drv_argument_not_allowed_with) << OSXVersion->getAsString(Args) << iPhoneVersion->getAsString(Args); iPhoneVersion = 0; } else if (!OSXVersion && !iPhoneVersion) { // If neither OS X nor iPhoneOS targets were specified, check for // environment defines. const char *OSXTarget = ::getenv("MACOSX_DEPLOYMENT_TARGET"); const char *iPhoneOSTarget = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"); // Ignore empty strings. if (OSXTarget && OSXTarget[0] == '\0') OSXTarget = 0; if (iPhoneOSTarget && iPhoneOSTarget[0] == '\0') iPhoneOSTarget = 0; // Diagnose conflicting deployment targets, and choose default platform // based on the tool chain. // // FIXME: Don't hardcode default here. if (OSXTarget && iPhoneOSTarget) { // FIXME: We should see if we can get away with warning or erroring on // this. Perhaps put under -pedantic? if (getTriple().getArch() == llvm::Triple::arm || getTriple().getArch() == llvm::Triple::thumb) OSXVersion = 0; else iPhoneVersion = 0; } if (OSXTarget) { const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); OSXVersion = DAL->MakeJoinedArg(0, O, OSXTarget); DAL->append(OSXVersion); } else if (iPhoneOSTarget) { const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ); iPhoneVersion = DAL->MakeJoinedArg(0, O, iPhoneOSTarget); DAL->append(iPhoneVersion); } else { // Otherwise, choose a default platform based on the tool chain. // // FIXME: Don't hardcode default here. if (getTriple().getArch() == llvm::Triple::arm || getTriple().getArch() == llvm::Triple::thumb) { const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ); iPhoneVersion = DAL->MakeJoinedArg(0, O, "3.0"); DAL->append(iPhoneVersion); } else { const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); OSXVersion = DAL->MakeJoinedArg(0, O, MacosxVersionMin); DAL->append(OSXVersion); } } } // Set the tool chain target information. unsigned Major, Minor, Micro; bool HadExtra; if (OSXVersion) { assert(!iPhoneVersion && "Unknown target platform!"); if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor, Micro, HadExtra) || HadExtra || Major != 10 || Minor >= 10 || Micro >= 10) getDriver().Diag(clang::diag::err_drv_invalid_version_number) << OSXVersion->getAsString(Args); } else { assert(iPhoneVersion && "Unknown target platform!"); if (!Driver::GetReleaseVersion(iPhoneVersion->getValue(Args), Major, Minor, Micro, HadExtra) || HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100) getDriver().Diag(clang::diag::err_drv_invalid_version_number) << iPhoneVersion->getAsString(Args); } setTarget(iPhoneVersion, Major, Minor, Micro); for (ArgList::iterator it = Args.begin(), ie = Args.end(); it != ie; ++it) { Arg *A = *it; if (A->getOption().matches(options::OPT_Xarch__)) { // FIXME: Canonicalize name. if (getArchName() != A->getValue(Args, 0)) continue; // FIXME: The arg is leaked here, and we should have a nicer // interface for this. unsigned Prev, Index = Prev = A->getIndex() + 1; Arg *XarchArg = Opts.ParseOneArg(Args, Index); // If the argument parsing failed or more than one argument was // consumed, the -Xarch_ argument's parameter tried to consume // extra arguments. Emit an error and ignore. // // We also want to disallow any options which would alter the // driver behavior; that isn't going to work in our model. We // use isDriverOption() as an approximation, although things // like -O4 are going to slip through. if (!XarchArg || Index > Prev + 1 || XarchArg->getOption().isDriverOption()) { getDriver().Diag(clang::diag::err_drv_invalid_Xarch_argument) << A->getAsString(Args); continue; } XarchArg->setBaseArg(A); A = XarchArg; } // Sob. These is strictly gcc compatible for the time being. Apple // gcc translates options twice, which means that self-expanding // options add duplicates. switch ((options::ID) A->getOption().getID()) { default: DAL->append(A); break; case options::OPT_mkernel: case options::OPT_fapple_kext: DAL->append(A); DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_static))); DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_static))); break; case options::OPT_dependency_file: DAL->append(DAL->MakeSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue(Args))); break; case options::OPT_gfull: DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_g_Flag))); DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols))); break; case options::OPT_gused: DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_g_Flag))); DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols))); break; case options::OPT_fterminated_vtables: case options::OPT_findirect_virtual_calls: DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_fapple_kext))); DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_static))); break; case options::OPT_shared: DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_dynamiclib))); break; case options::OPT_fconstant_cfstrings: DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings))); break; case options::OPT_fno_constant_cfstrings: DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings))); break; case options::OPT_Wnonportable_cfstrings: DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_mwarn_nonportable_cfstrings))); break; case options::OPT_Wno_nonportable_cfstrings: DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings))); break; case options::OPT_fpascal_strings: DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_mpascal_strings))); break; case options::OPT_fno_pascal_strings: DAL->append(DAL->MakeFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings))); break; } } if (getTriple().getArch() == llvm::Triple::x86 || getTriple().getArch() == llvm::Triple::x86_64) if (!Args.hasArgNoClaim(options::OPT_mtune_EQ)) DAL->append(DAL->MakeJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2")); // Add the arch options based on the particular spelling of -arch, to match // how the driver driver works. if (BoundArch) { llvm::StringRef Name = BoundArch; const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ); const Option *MArch = Opts.getOption(options::OPT_march_EQ); // This code must be kept in sync with LLVM's getArchTypeForDarwinArch, // which defines the list of which architectures we accept. if (Name == "ppc") ; else if (Name == "ppc601") DAL->append(DAL->MakeJoinedArg(0, MCpu, "601")); else if (Name == "ppc603") DAL->append(DAL->MakeJoinedArg(0, MCpu, "603")); else if (Name == "ppc604") DAL->append(DAL->MakeJoinedArg(0, MCpu, "604")); else if (Name == "ppc604e") DAL->append(DAL->MakeJoinedArg(0, MCpu, "604e")); else if (Name == "ppc750") DAL->append(DAL->MakeJoinedArg(0, MCpu, "750")); else if (Name == "ppc7400") DAL->append(DAL->MakeJoinedArg(0, MCpu, "7400")); else if (Name == "ppc7450") DAL->append(DAL->MakeJoinedArg(0, MCpu, "7450")); else if (Name == "ppc970") DAL->append(DAL->MakeJoinedArg(0, MCpu, "970")); else if (Name == "ppc64") DAL->append(DAL->MakeFlagArg(0, Opts.getOption(options::OPT_m64))); else if (Name == "i386") ; else if (Name == "i486") DAL->append(DAL->MakeJoinedArg(0, MArch, "i486")); else if (Name == "i586") DAL->append(DAL->MakeJoinedArg(0, MArch, "i586")); else if (Name == "i686") DAL->append(DAL->MakeJoinedArg(0, MArch, "i686")); else if (Name == "pentium") DAL->append(DAL->MakeJoinedArg(0, MArch, "pentium")); else if (Name == "pentium2") DAL->append(DAL->MakeJoinedArg(0, MArch, "pentium2")); else if (Name == "pentpro") DAL->append(DAL->MakeJoinedArg(0, MArch, "pentiumpro")); else if (Name == "pentIIm3") DAL->append(DAL->MakeJoinedArg(0, MArch, "pentium2")); else if (Name == "x86_64") DAL->append(DAL->MakeFlagArg(0, Opts.getOption(options::OPT_m64))); else if (Name == "arm") DAL->append(DAL->MakeJoinedArg(0, MArch, "armv4t")); else if (Name == "armv4t") DAL->append(DAL->MakeJoinedArg(0, MArch, "armv4t")); else if (Name == "armv5") DAL->append(DAL->MakeJoinedArg(0, MArch, "armv5tej")); else if (Name == "xscale") DAL->append(DAL->MakeJoinedArg(0, MArch, "xscale")); else if (Name == "armv6") DAL->append(DAL->MakeJoinedArg(0, MArch, "armv6k")); else if (Name == "armv7") DAL->append(DAL->MakeJoinedArg(0, MArch, "armv7a")); else llvm_unreachable("invalid Darwin arch"); } return DAL; }
llvm::opt::DerivedArgList * ToolChain::TranslateOpenMPTargetArgs(const llvm::opt::DerivedArgList &Args, Action::OffloadKind DeviceOffloadKind) const { if (DeviceOffloadKind == Action::OFK_OpenMP) { DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); const OptTable &Opts = getDriver().getOpts(); bool NewArgAdded = false; // Handle -Xopenmp-target flags for (Arg *A : Args) { // Exclude flags which may only apply to the host toolchain. // Do not exclude flags when the host triple (AuxTriple), // matches the current toolchain triple. if (A->getOption().matches(options::OPT_m_Group)) { if (getAuxTriple() && getAuxTriple()->str() == getTriple().str()) DAL->append(A); continue; } unsigned Index; unsigned Prev; bool XOpenMPTargetNoTriple = A->getOption().matches( options::OPT_Xopenmp_target); if (A->getOption().matches(options::OPT_Xopenmp_target_EQ)) { // Passing device args: -Xopenmp-target=<triple> -opt=val. if (A->getValue(0) == getTripleString()) Index = Args.getBaseArgs().MakeIndex(A->getValue(1)); else continue; } else if (XOpenMPTargetNoTriple) { // Passing device args: -Xopenmp-target -opt=val. Index = Args.getBaseArgs().MakeIndex(A->getValue(0)); } else { DAL->append(A); continue; } // Parse the argument to -Xopenmp-target. Prev = Index; std::unique_ptr<Arg> XOpenMPTargetArg(Opts.ParseOneArg(Args, Index)); if (!XOpenMPTargetArg || Index > Prev + 1) { getDriver().Diag(diag::err_drv_invalid_Xopenmp_target_with_args) << A->getAsString(Args); continue; } if (XOpenMPTargetNoTriple && XOpenMPTargetArg && Args.getAllArgValues( options::OPT_fopenmp_targets_EQ).size() != 1) { getDriver().Diag(diag::err_drv_Xopenmp_target_missing_triple); continue; } XOpenMPTargetArg->setBaseArg(A); A = XOpenMPTargetArg.release(); DAL->append(A); NewArgAdded = true; } if (NewArgAdded) { return DAL; } else { delete DAL; } } return nullptr; }
DerivedArgList *Darwin::TranslateArgs(const DerivedArgList &Args, const char *BoundArch) const { DerivedArgList *DAL = new DerivedArgList(Args.getBaseArgs()); const OptTable &Opts = getDriver().getOpts(); // FIXME: We really want to get out of the tool chain level argument // translation business, as it makes the driver functionality much // more opaque. For now, we follow gcc closely solely for the // purpose of easily achieving feature parity & testability. Once we // have something that works, we should reevaluate each translation // and try to push it down into tool specific logic. for (ArgList::const_iterator it = Args.begin(), ie = Args.end(); it != ie; ++it) { Arg *A = *it; if (A->getOption().matches(options::OPT_Xarch__)) { // FIXME: Canonicalize name. if (getArchName() != A->getValue(Args, 0)) continue; unsigned Index = Args.getBaseArgs().MakeIndex(A->getValue(Args, 1)); unsigned Prev = Index; Arg *XarchArg = Opts.ParseOneArg(Args, Index); // If the argument parsing failed or more than one argument was // consumed, the -Xarch_ argument's parameter tried to consume // extra arguments. Emit an error and ignore. // // We also want to disallow any options which would alter the // driver behavior; that isn't going to work in our model. We // use isDriverOption() as an approximation, although things // like -O4 are going to slip through. if (!XarchArg || Index > Prev + 1 || XarchArg->getOption().isDriverOption()) { getDriver().Diag(clang::diag::err_drv_invalid_Xarch_argument) << A->getAsString(Args); continue; } XarchArg->setBaseArg(A); A = XarchArg; DAL->AddSynthesizedArg(A); } // Sob. These is strictly gcc compatible for the time being. Apple // gcc translates options twice, which means that self-expanding // options add duplicates. switch ((options::ID) A->getOption().getID()) { default: DAL->append(A); break; case options::OPT_mkernel: case options::OPT_fapple_kext: DAL->append(A); DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); break; case options::OPT_dependency_file: DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue(Args)); break; case options::OPT_gfull: DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); DAL->AddFlagArg(A, Opts.getOption(options::OPT_fno_eliminate_unused_debug_symbols)); break; case options::OPT_gused: DAL->AddFlagArg(A, Opts.getOption(options::OPT_g_Flag)); DAL->AddFlagArg(A, Opts.getOption(options::OPT_feliminate_unused_debug_symbols)); break; case options::OPT_fterminated_vtables: case options::OPT_findirect_virtual_calls: DAL->AddFlagArg(A, Opts.getOption(options::OPT_fapple_kext)); DAL->AddFlagArg(A, Opts.getOption(options::OPT_static)); break; case options::OPT_shared: DAL->AddFlagArg(A, Opts.getOption(options::OPT_dynamiclib)); break; case options::OPT_fconstant_cfstrings: DAL->AddFlagArg(A, Opts.getOption(options::OPT_mconstant_cfstrings)); break; case options::OPT_fno_constant_cfstrings: DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_constant_cfstrings)); break; case options::OPT_Wnonportable_cfstrings: DAL->AddFlagArg(A, Opts.getOption(options::OPT_mwarn_nonportable_cfstrings)); break; case options::OPT_Wno_nonportable_cfstrings: DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_warn_nonportable_cfstrings)); break; case options::OPT_fpascal_strings: DAL->AddFlagArg(A, Opts.getOption(options::OPT_mpascal_strings)); break; case options::OPT_fno_pascal_strings: DAL->AddFlagArg(A, Opts.getOption(options::OPT_mno_pascal_strings)); break; } } if (getTriple().getArch() == llvm::Triple::x86 || getTriple().getArch() == llvm::Triple::x86_64) if (!Args.hasArgNoClaim(options::OPT_mtune_EQ)) DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mtune_EQ), "core2"); // Add the arch options based on the particular spelling of -arch, to match // how the driver driver works. if (BoundArch) { llvm::StringRef Name = BoundArch; const Option *MCpu = Opts.getOption(options::OPT_mcpu_EQ); const Option *MArch = Opts.getOption(options::OPT_march_EQ); // This code must be kept in sync with LLVM's getArchTypeForDarwinArch, // which defines the list of which architectures we accept. if (Name == "ppc") ; else if (Name == "ppc601") DAL->AddJoinedArg(0, MCpu, "601"); else if (Name == "ppc603") DAL->AddJoinedArg(0, MCpu, "603"); else if (Name == "ppc604") DAL->AddJoinedArg(0, MCpu, "604"); else if (Name == "ppc604e") DAL->AddJoinedArg(0, MCpu, "604e"); else if (Name == "ppc750") DAL->AddJoinedArg(0, MCpu, "750"); else if (Name == "ppc7400") DAL->AddJoinedArg(0, MCpu, "7400"); else if (Name == "ppc7450") DAL->AddJoinedArg(0, MCpu, "7450"); else if (Name == "ppc970") DAL->AddJoinedArg(0, MCpu, "970"); else if (Name == "ppc64") DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64)); else if (Name == "i386") ; else if (Name == "i486") DAL->AddJoinedArg(0, MArch, "i486"); else if (Name == "i586") DAL->AddJoinedArg(0, MArch, "i586"); else if (Name == "i686") DAL->AddJoinedArg(0, MArch, "i686"); else if (Name == "pentium") DAL->AddJoinedArg(0, MArch, "pentium"); else if (Name == "pentium2") DAL->AddJoinedArg(0, MArch, "pentium2"); else if (Name == "pentpro") DAL->AddJoinedArg(0, MArch, "pentiumpro"); else if (Name == "pentIIm3") DAL->AddJoinedArg(0, MArch, "pentium2"); else if (Name == "x86_64") DAL->AddFlagArg(0, Opts.getOption(options::OPT_m64)); else if (Name == "arm") DAL->AddJoinedArg(0, MArch, "armv4t"); else if (Name == "armv4t") DAL->AddJoinedArg(0, MArch, "armv4t"); else if (Name == "armv5") DAL->AddJoinedArg(0, MArch, "armv5tej"); else if (Name == "xscale") DAL->AddJoinedArg(0, MArch, "xscale"); else if (Name == "armv6") DAL->AddJoinedArg(0, MArch, "armv6k"); else if (Name == "armv7") DAL->AddJoinedArg(0, MArch, "armv7a"); else llvm_unreachable("invalid Darwin arch"); } // Add an explicit version min argument for the deployment target. We do this // after argument translation because -Xarch_ arguments may add a version min // argument. AddDeploymentTarget(*DAL); return DAL; }
void Darwin::AddDeploymentTarget(DerivedArgList &Args) const { const OptTable &Opts = getDriver().getOpts(); Arg *OSXVersion = Args.getLastArg(options::OPT_mmacosx_version_min_EQ); Arg *iPhoneVersion = Args.getLastArg(options::OPT_miphoneos_version_min_EQ); if (OSXVersion && iPhoneVersion) { getDriver().Diag(clang::diag::err_drv_argument_not_allowed_with) << OSXVersion->getAsString(Args) << iPhoneVersion->getAsString(Args); iPhoneVersion = 0; } else if (!OSXVersion && !iPhoneVersion) { // If neither OS X nor iPhoneOS targets were specified, check for // environment defines. const char *OSXTarget = ::getenv("MACOSX_DEPLOYMENT_TARGET"); const char *iPhoneOSTarget = ::getenv("IPHONEOS_DEPLOYMENT_TARGET"); // Ignore empty strings. if (OSXTarget && OSXTarget[0] == '\0') OSXTarget = 0; if (iPhoneOSTarget && iPhoneOSTarget[0] == '\0') iPhoneOSTarget = 0; // Diagnose conflicting deployment targets, and choose default platform // based on the tool chain. // // FIXME: Don't hardcode default here. if (OSXTarget && iPhoneOSTarget) { // FIXME: We should see if we can get away with warning or erroring on // this. Perhaps put under -pedantic? if (getTriple().getArch() == llvm::Triple::arm || getTriple().getArch() == llvm::Triple::thumb) OSXTarget = 0; else iPhoneOSTarget = 0; } if (OSXTarget) { const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); OSXVersion = Args.MakeJoinedArg(0, O, OSXTarget); Args.append(OSXVersion); } else if (iPhoneOSTarget) { const Option *O = Opts.getOption(options::OPT_miphoneos_version_min_EQ); iPhoneVersion = Args.MakeJoinedArg(0, O, iPhoneOSTarget); Args.append(iPhoneVersion); } else { // Otherwise, assume we are targeting OS X. const Option *O = Opts.getOption(options::OPT_mmacosx_version_min_EQ); OSXVersion = Args.MakeJoinedArg(0, O, MacosxVersionMin); Args.append(OSXVersion); } } // Set the tool chain target information. unsigned Major, Minor, Micro; bool HadExtra; if (OSXVersion) { assert(!iPhoneVersion && "Unknown target platform!"); if (!Driver::GetReleaseVersion(OSXVersion->getValue(Args), Major, Minor, Micro, HadExtra) || HadExtra || Major != 10 || Minor >= 10 || Micro >= 10) getDriver().Diag(clang::diag::err_drv_invalid_version_number) << OSXVersion->getAsString(Args); } else { assert(iPhoneVersion && "Unknown target platform!"); if (!Driver::GetReleaseVersion(iPhoneVersion->getValue(Args), Major, Minor, Micro, HadExtra) || HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100) getDriver().Diag(clang::diag::err_drv_invalid_version_number) << iPhoneVersion->getAsString(Args); } setTarget(iPhoneVersion, Major, Minor, Micro); }