[Driver] Allow warning for unclaimed TargetSpecific options

[MaskRay]

Summary

For unclaimed target-agnostic options, we can apply clang_ignored_gcc_optimization_f_Group
to accept but warn about them.

% clang -c -fexpensive-optimizations a.c
clang: warning: optimization flag '-fexpensive-optimizations' is not supported [-Wignored-optimization-argument]

For an unclaimed target-specific option, one target may want to accept but warn
about it. Add llvm::opt::Arg::IgnoredTargetSpecific to support this warning
need.

Close https://github.com/llvm/llvm-project/issues/63282

[mstorsjo]

Looks great to me, thanks! (Didn't test it myself yet though.) Just one small nit.

llvm/include/llvm/Option/Arg.h

53

Technically, as this is a llvm level API, talking about clang specific behaviours here is a bit at the wrong level.

[MaskRay]

llvm/include/llvm/Option/Arg.h

53

Yes. LLVMOption was originally part of Clang and was moved to llvm/.

The "argument unused" string is also quite Clang-specific. There are other stuff talking about Clang behaviors, e.g. suggestValueCompletions, Alias (-finput-charset=utf-8). I wish that this is not too bad.

[mstorsjo]

llvm/include/llvm/Option/Arg.h

53

Ok, fair enough - consider this remark withdrawn then. Even if mislayered, detailed comments explaining the reason for the field is better than no explanations.

[MaskRay]

avoid mutable

clang/include/clang/Driver/Options.td

 def m32 : Flag<["-"], "m32">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>;
 def maix32 : Flag<["-"], "maix32">, Group<m_Group>, Flags<[NoXarchOption]>;
 def mqdsp6_compat : Flag<["-"], "mqdsp6-compat">, Group<m_Group>, Flags<[NoXarchOption,CC1Option]>,
   HelpText<"Enable hexagon-qdsp6 backward compatibility">,
   MarshallingInfoFlag<LangOpts<"HexagonQdsp6Compat">>;
 def m64 : Flag<["-"], "m64">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>;
 def maix64 : Flag<["-"], "maix64">, Group<m_Group>, Flags<[NoXarchOption]>;
 def mx32 : Flag<["-"], "mx32">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>;
-def mabi_EQ : Joined<["-"], "mabi=">, Group<m_Group>;
 def miamcu : Flag<["-"], "miamcu">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>,
   HelpText<"Use Intel MCU ABI">;
 def mno_iamcu : Flag<["-"], "mno-iamcu">, Group<m_Group>, Flags<[NoXarchOption, CoreOption]>;
 def malign_functions_EQ : Joined<["-"], "malign-functions=">, Group<clang_ignored_m_Group>;
 def malign_loops_EQ : Joined<["-"], "malign-loops=">, Group<clang_ignored_m_Group>;
 def malign_jumps_EQ : Joined<["-"], "malign-jumps=">, Group<clang_ignored_m_Group>;
 
 let Flags = [TargetSpecific] in {
+def mabi_EQ : Joined<["-"], "mabi=">, Group<m_Group>;
 def malign_branch_EQ : CommaJoined<["-"], "malign-branch=">, Group<m_Group>,
   HelpText<"Specify types of branches to align">;
 def malign_branch_boundary_EQ : Joined<["-"], "malign-branch-boundary=">, Group<m_Group>,
   HelpText<"Specify the boundary's size to align branches">;
 def mpad_max_prefix_size_EQ : Joined<["-"], "mpad-max-prefix-size=">, Group<m_Group>,
   HelpText<"Specify maximum number of prefixes to use for padding">;
 def mbranches_within_32B_boundaries : Flag<["-"], "mbranches-within-32B-boundaries">, Group<m_Group>,
   HelpText<"Align selected branches (fused, jcc, jmp) within 32-byte boundary">;

 def mno_inline_all_stringops : Flag<["-"], "mno-inline-all-stringops">, Group<clang_ignored_m_Group>;
 } // let Flags = [TargetSpecific]
 def malign_double : Flag<["-"], "malign-double">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Align doubles to two words in structs (x86 only)">,
   MarshallingInfoFlag<LangOpts<"AlignDouble">>;
 let Flags = [TargetSpecific] in {
 def mfloat_abi_EQ : Joined<["-"], "mfloat-abi=">, Group<m_Group>, Values<"soft,softfp,hard">;
 def mfpmath_EQ : Joined<["-"], "mfpmath=">, Group<m_Group>;
-} // let Flags = [TargetSpecific]
 def mfpu_EQ : Joined<["-"], "mfpu=">, Group<m_Group>;
-let Flags = [TargetSpecific] in {
 def mhwdiv_EQ : Joined<["-"], "mhwdiv=">, Group<m_Group>;
 def mhwmult_EQ : Joined<["-"], "mhwmult=">, Group<m_Group>;
 } // let Flags = [TargetSpecific]
 def mglobal_merge : Flag<["-"], "mglobal-merge">, Group<m_Group>, Flags<[CC1Option]>,
   HelpText<"Enable merging of globals">;
 let Flags = [TargetSpecific] in {
 def mhard_float : Flag<["-"], "mhard-float">, Group<m_Group>;
 def mios_version_min_EQ : Joined<["-"], "mios-version-min=">,

clang/lib/Driver/Driver.cpp

if (!A->isClaimed()) {
 
         if (DuplicateClaimed)
           continue;
       }
 
       // In clang-cl, don't mention unknown arguments here since they have
       // already been warned about.
       if (!IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN)) {
-        if (A->getOption().hasFlag(options::TargetSpecific)) {
+        if (A->getOption().hasFlag(options::TargetSpecific) &&
+            !A->isIgnoredTargetSpecific()) {
           Diag(diag::err_drv_unsupported_opt_for_target)
               << A->getSpelling() << getTargetTriple();
         } else {
           Diag(clang::diag::warn_drv_unused_argument)
               << A->getAsString(C.getArgs());
         }
       }
     }

clang/lib/Driver/ToolChains/Arch/LoongArch.cpp

if (FPU == "64") {
       D.Diag(diag::err_drv_loongarch_invalid_mfpu_EQ) << FPU;
     }
   }
 
   // Select the `ual` feature determined by -m[no-]unaligned-access
   // or the alias -m[no-]strict-align.
   AddTargetFeature(Args, Features, options::OPT_munaligned_access,
                    options::OPT_mno_unaligned_access, "ual");
+
+  // Accept but warn about these TargetSpecific options.
+  if (Arg *A = Args.getLastArgNoClaim(options::OPT_mabi_EQ))
+    A->ignoreTargetSpecific();
+  if (Arg *A = Args.getLastArgNoClaim(options::OPT_mfpu_EQ))
+    A->ignoreTargetSpecific();
 }

clang/lib/Driver/ToolChains/MinGW.cpp

if (Arg *A = DriverArgs.getLastArg(options::OPT_mguard_EQ)) {
     } else if (GuardArgs == "cf-nochecks") {
       // Emit only the table of address-taken functions.
       CC1Args.push_back("-cfguard-no-checks");
     } else {
       getDriver().Diag(diag::err_drv_unsupported_option_argument)
           << A->getSpelling() << GuardArgs;
     }
   }
+
+  if (Arg *A = DriverArgs.getLastArgNoClaim(options::OPT_mthreads))
+    A->ignoreTargetSpecific();
 }
 
 void toolchains::MinGW::AddClangCXXStdlibIncludeArgs(
     const ArgList &DriverArgs, ArgStringList &CC1Args) const {
   if (DriverArgs.hasArg(options::OPT_nostdinc, options::OPT_nostdlibinc,
                         options::OPT_nostdincxx))
     return;
 

llvm/include/llvm/Option/Arg.h

private:
 
   /// How this instance of the option was spelled.
   StringRef Spelling;
 
   /// The index at which this argument appears in the containing
   /// ArgList.
   unsigned Index;
 
-  /// Was this argument used to effect compilation?
+  /// Was this argument used to affect compilation?
   ///
-  /// This is used for generating "argument unused" diagnostics.
+  /// This is used to generate an "argument unused" warning (without
+  /// clang::driver::options::TargetSpecific) or "unsupported option" error
+  /// (with TargetSpecific).
   mutable unsigned Claimed : 1;
 
+  /// Used by an unclaimed option with the TargetSpecific flag. If set, report
+  /// an "argument unused" warning instead of an "unsupported option" error.
+  unsigned IgnoredTargetSpecific : 1;
+
   /// Does this argument own its values?
   mutable unsigned OwnsValues : 1;
 
   /// The argument values, as C strings.
   SmallVector<const char *, 2> Values;
 
   /// If this arg was created through an alias, this is the original alias arg.
   /// For example, *this might be "-finput-charset=utf-8" and Alias might
public:
 
   /// Return the base argument which generated this arg.
   ///
   /// This is either the argument itself or the argument it was
   /// derived from during tool chain specific argument translation.
   const Arg &getBaseArg() const {
     return BaseArg ? *BaseArg : *this;
   }
+  Arg &getBaseArg() { return BaseArg ? const_cast<Arg &>(*BaseArg) : *this; }
   void setBaseArg(const Arg *BaseArg) { this->BaseArg = BaseArg; }
 
   /// Args are converted to their unaliased form.  For args that originally
   /// came from an alias, this returns the alias the arg was produced from.
   const Arg* getAlias() const { return Alias.get(); }
   void setAlias(std::unique_ptr<Arg> Alias) { this->Alias = std::move(Alias); }
 
   bool getOwnsValues() const { return OwnsValues; }
   void setOwnsValues(bool Value) const { OwnsValues = Value; }
 
   bool isClaimed() const { return getBaseArg().Claimed; }
-
-  /// Set the Arg claimed bit.
   void claim() const { getBaseArg().Claimed = true; }
 
+  bool isIgnoredTargetSpecific() const {
+    return getBaseArg().IgnoredTargetSpecific;
+  }
+  void ignoreTargetSpecific() {
+    getBaseArg().IgnoredTargetSpecific = true;
+  }
+
   unsigned getNumValues() const { return Values.size(); }
 
   const char *getValue(unsigned N = 0) const {
     return Values[N];
   }
 
   SmallVectorImpl<const char *> &getValues() { return Values; }
   const SmallVectorImpl<const char *> &getValues() const { return Values; }

llvm/lib/Option/Arg.cpp

 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::opt;
 
 Arg::Arg(const Option Opt, StringRef S, unsigned Index, const Arg *BaseArg)
     : Opt(Opt), BaseArg(BaseArg), Spelling(S), Index(Index), Claimed(false),
-      OwnsValues(false) {}
+      IgnoredTargetSpecific(false), OwnsValues(false) {}
 
 Arg::Arg(const Option Opt, StringRef S, unsigned Index, const char *Value0,
          const Arg *BaseArg)
     : Opt(Opt), BaseArg(BaseArg), Spelling(S), Index(Index), Claimed(false),
-      OwnsValues(false) {
+      IgnoredTargetSpecific(false), OwnsValues(false) {
   Values.push_back(Value0);
 }
 
 Arg::Arg(const Option Opt, StringRef S, unsigned Index, const char *Value0,
          const char *Value1, const Arg *BaseArg)
     : Opt(Opt), BaseArg(BaseArg), Spelling(S), Index(Index), Claimed(false),
-      OwnsValues(false) {
+      IgnoredTargetSpecific(false), OwnsValues(false) {
   Values.push_back(Value0);
   Values.push_back(Value1);
 }
 
 Arg::~Arg() {
   if (OwnsValues) {
     for (unsigned i = 0, e = Values.size(); i != e; ++i)
       delete[] Values[i];