[Driver] implement -feverything

[nickdesaulniers]

Summary

Due to the wild popularity of -Weverything (used for enabling all
warnings), we're back for round 2 (electric boogaloo) with a succinct
analog to enable all -f flags; -feverything.

This includes favorite hits like:

• -funsafe-math-optimizations
  • who knew floating point math could be BOTH fun and safe, WHO KNEW?!1
• your favorite language extensions
  • -fborland-extensions
  • -fms-extensions
  • -fheinous-gnu-extensions
  • -fplan9-extensions (TODO: implement like GCC)
• flags specific to languages (whether you're using them or not) like:
  • CUDA
  • FORTRAN
  • Objective-C
  • OpenMP
• flags specific to target (whether you're targeting them or not) like:
  • -faltivec
  • -fcray-pointer
  • -fcall-saved-*/-ffixed-* (aka "build your own calling convention!")
• I don't know what these do, but they sound nice:
  • -fmudflap
  • -fdollar-ok
  • -fropi
  • -frwpi

Can't decide between the overflow behavior of -fwrapv or -ftrapv?
¿Porque No Los Dos?

Next time you're having trouble getting your code to compile, try
-feverything.

TODO:

• unit tests (honestly afraid to run this outside a VM, though this does

enable all runtime sanitizers for extra safety).

• -fno-everything

[srhines]

In addition to -fno-everything, don't forget about -fnothing and -fno-nothing, which seem like they would also be nice to have.

[yuxuanchen1997]

enable all runtime sanitizers for extra safety

Brilliant idea. But I wonder how that could be done for -fsanitize. ASAN and MSAN can't be used together.

[lebedev.ri]

In D60059#1450252, @yuxuanchen1997 wrote:

enable all runtime sanitizers for extra safety

Brilliant idea. But I wonder how that could be done for -fsanitize. ASAN and MSAN can't be used together.

Nonsense.
There is a patch that allows to offload the shadow memory onto the cloud via blockchain,
in encrypted form for extra security of course. That will allow to use both sanitizers together.

[pcc]

In D60059#1450320, @lebedev.ri wrote:

In D60059#1450252, @yuxuanchen1997 wrote:

enable all runtime sanitizers for extra safety

Brilliant idea. But I wonder how that could be done for -fsanitize. ASAN and MSAN can't be used together.

Nonsense.
There is a patch that allows to offload the shadow memory onto the cloud via blockchain,
in encrypted form for extra security of course. That will allow to use both sanitizers together.

That's unsurprising, given that LLVM already contains blockchain technology.
http://llvm-cs.pcc.me.uk/lib/CodeGen/MachineBlockPlacement.cpp#214

clang/include/clang/Driver/Options.td

def T : JoinedOrSeparate<["-"], "T">, Group<T_Group>,
   MetaVarName<"<script>">, HelpText<"Specify <script> as linker script">;
 def U : JoinedOrSeparate<["-"], "U">, Group<Preprocessor_Group>,
   Flags<[CC1Option]>, MetaVarName<"<macro>">, HelpText<"Undefine macro <macro>">;
 def V : JoinedOrSeparate<["-"], "V">, Flags<[DriverOption, Unsupported]>;
 def Wa_COMMA : CommaJoined<["-"], "Wa,">,
   HelpText<"Pass the comma separated arguments in <arg> to the assembler">,
   MetaVarName<"<arg>">;
 def Wall : Flag<["-"], "Wall">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
+def feverything : Flag<["-"], "feverything">, Group<f_Group>, Flags<[CC1Option, HelpHidden]>;
 def WCL4 : Flag<["-"], "WCL4">, Group<W_Group>, Flags<[CC1Option, HelpHidden]>;
 def Wdeprecated : Flag<["-"], "Wdeprecated">, Group<W_Group>, Flags<[CC1Option]>,
   HelpText<"Enable warnings for deprecated constructs and define __DEPRECATED">;
 def Wno_deprecated : Flag<["-"], "Wno-deprecated">, Group<W_Group>, Flags<[CC1Option]>;
 def Wl_COMMA : CommaJoined<["-"], "Wl,">, Flags<[LinkerInput, RenderAsInput]>,
   HelpText<"Pass the comma separated arguments in <arg> to the linker">,
   MetaVarName<"<arg>">, Group<Link_Group>;
 // FIXME: This is broken; these should not be Joined arguments.

clang/include/clang/Frontend/CompilerInvocation.h

 
 namespace llvm {
 
 class Triple;
 
 namespace opt {
 
 class ArgList;
+class InputArgList;
+class OptTable;
 
 } // namespace opt
 
 namespace vfs {
 
 class FileSystem;
 
 } // namespace vfs

 ///
 /// When errors are encountered, return false and, if Diags is non-null,
 /// report the error(s).
 bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args,
                          DiagnosticsEngine *Diags = nullptr,
                          bool DefaultDiagColor = true,
                          bool DefaultShowOpt = true);
 
+void ParseFEverything(llvm::opt::OptTable *Opts, llvm::opt::InputArgList *Args);
+
 class CompilerInvocationBase {
 public:
   /// Options controlling the language variant.
   std::shared_ptr<LangOptions> LangOpts;
 
   /// Options controlling the target.
   std::shared_ptr<TargetOptions> TargetOpts;
 

clang/lib/Driver/ToolChains/Clang.cpp

if (A->getOption().matches(options::OPT_moutline)) {
       }
     } else {
       // Disable all outlining behaviour.
       CmdArgs.push_back("-mllvm");
       CmdArgs.push_back("-enable-machine-outliner=never");
     }
   }
 
+  if (Args.hasArg(options::OPT_feverything))
+    CmdArgs.push_back("-feverything");
+
   if (Args.hasFlag(options::OPT_faddrsig, options::OPT_fno_addrsig,
                    (TC.getTriple().isOSBinFormatELF() ||
                     TC.getTriple().isOSBinFormatCOFF()) &&
                       !TC.getTriple().isPS4() &&
                       !TC.getTriple().isOSNetBSD() &&
                       !Distro(D.getVFS()).IsGentoo() &&
                       !TC.getTriple().isAndroid() &&
                        TC.useIntegratedAs()))

clang/lib/Frontend/CompilerInvocation.cpp

if (BadChar != Prefix.end() || !isLetter(Prefix[0])) {
         Diags->Report(diag::err_drv_invalid_value) << "-verify=" << Prefix;
         Diags->Report(diag::note_drv_verify_prefix_spelling);
       }
     }
   }
   return Success;
 }
 
+void clang::ParseFEverything(llvm::opt::OptTable *Opts,
+                             llvm::opt::InputArgList *Args) {
+  if (!Args->hasArg(options::OPT_feverything))
+    return;
+  const unsigned f_group = Opts->getOption(OPT_f_Group).getID();
+  unsigned i = Opts->getFirstSearchableIndex();
+  const unsigned len = Opts->getNumOptions();
+  for (; i != len; ++i) {
+    const Option &opt = Opts->getOption(i);
+    const Option group = opt.getGroup();
+    // TODO: add more groups
+    if (group.isValid() && group.getID() == f_group) {
+      const std::string Flag = opt.getPrefixedName();
+      if (Flag.back() != '=' && Flag.back() != '-')
+        Args->append(new Arg(opt, Flag, Args->MakeIndex(Flag), Flag.c_str()));
+    }
+  }
+}
+
 bool clang::ParseDiagnosticArgs(DiagnosticOptions &Opts, ArgList &Args,
                                 DiagnosticsEngine *Diags,
                                 bool DefaultDiagColor, bool DefaultShowOpt) {
   bool Success = true;
 
   Opts.DiagnosticLogFile = Args.getLastArgValue(OPT_diagnostic_log_file);
   if (Arg *A =
           Args.getLastArg(OPT_diagnostic_serialized_file, OPT__serialize_diags))
bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
 
   // Parse the arguments.
   std::unique_ptr<OptTable> Opts = createDriverOptTable();
   const unsigned IncludedFlagsBitmask = options::CC1Option;
   unsigned MissingArgIndex, MissingArgCount;
   InputArgList Args =
       Opts->ParseArgs(llvm::makeArrayRef(ArgBegin, ArgEnd), MissingArgIndex,
                       MissingArgCount, IncludedFlagsBitmask);
+  ParseFEverything(Opts.get(), &Args);
   LangOptions &LangOpts = *Res.getLangOpts();
 
   // Check for missing argument error.
   if (MissingArgCount) {
     Diags.Report(diag::err_drv_missing_argument)
         << Args.getArgString(MissingArgIndex) << MissingArgCount;
     Success = false;
   }

llvm/include/llvm/Option/OptTable.h

protected:
   OptTable(ArrayRef<Info> OptionInfos, bool IgnoreCase = false);
 
 public:
   ~OptTable();
 
   /// Return the total number of option classes.
   unsigned getNumOptions() const { return OptionInfos.size(); }
 
+  unsigned getFirstSearchableIndex() const { return FirstSearchableIndex; }
+
   /// Get the given Opt's Option instance, lazily creating it
   /// if necessary.
   ///
   /// \return The option, or null for the INVALID option id.
   const Option getOption(OptSpecifier Opt) const;
 
   /// Lookup the name of the given option.
   const char *getOptionName(OptSpecifier id) const {