[RFC] Call ParseLangArgs for all inputs

[hvdijk]

Summary

clang/lib/CodeGen/BackendUtil.cpp contains multiple checks for attributes of LangOpts. The option processing that sets up LangOpts is mostly done by ParseLangArgs, which is skipped for LLVM IR files. Because of this, there are code generation differences when the -save-temps command line option is used: that command line option causes LLVM IR to be emitted to file and a new process to be spawned to process that file, which does not process options the same way.

An example of this is

typedef float __attribute__((ext_vector_type(2))) float2;
float2 foo (float2 a, float2 b, float2 c) {
  return a * b + c;
}

This used to generate different code with clang --target=mips -mcpu=mips32r5 -mfp64 -mmsa -O3 -ffp-contract=fast depending on whether -save-temps was also present, because the -ffp-contract=fast option affects instruction selection but was ignored for LLVM IR input files.

While CompilerInvocation::CreateFromArgs contained special exceptions for a few options that were handled by ParseLangArgs that also need to be handled for LLVM IR, there are many more, and just allowing ParseLangArgs to be called seems like the simpler fix.

For InputKind::Precompiled, -std=* options were previously silently ignored and continue to be silently ignored, as it is reasonable for users to add them and in fact this is done in quite a number of tests in the test suite.

For Language::LLVM_IR, -std=* options were previously silently ignored and now result in an error, as it is not reasonable for users to add them.

clang/lib/Frontend/CompilerInvocation.cpp

static Visibility parseVisibility(Arg *arg, ArgList &args,
   return DefaultVisibility;
 }
 
 /// Check if input file kind and language standard are compatible.
 static bool IsInputCompatibleWithStandard(InputKind IK,
                                           const LangStandard &S) {
   switch (IK.getLanguage()) {
   case Language::Unknown:
-  case Language::LLVM_IR:
     llvm_unreachable("should not parse language flags for this input");
 
+  case Language::LLVM_IR:
+    return false;
+
   case Language::C:
   case Language::ObjC:
   case Language::RenderScript:
     return S.getLanguage() == Language::C;
 
   case Language::OpenCL:
     return S.getLanguage() == Language::OpenCL;
 
static void ParseLangArgs(LangOptions &Opts, ArgList &Args, InputKind IK,
                           DiagnosticsEngine &Diags) {
   // FIXME: Cleanup per-file based stuff.
   LangStandard::Kind LangStd = LangStandard::lang_unspecified;
   if (const Arg *A = Args.getLastArg(OPT_std_EQ)) {
     LangStd = LangStandard::getLangKind(A->getValue());
     if (LangStd == LangStandard::lang_unspecified) {
       Diags.Report(diag::err_drv_invalid_value)
         << A->getAsString(Args) << A->getValue();
+      if (IK.getFormat() != InputKind::Precompiled) {
         // Report supported standards with short description.
         for (unsigned KindValue = 0;
              KindValue != LangStandard::lang_unspecified;
              ++KindValue) {
           const LangStandard &Std = LangStandard::getLangStandardForKind(
             static_cast<LangStandard::Kind>(KindValue));
           if (IsInputCompatibleWithStandard(IK, Std)) {
             auto Diag = Diags.Report(diag::note_drv_use_standard);
             Diag << Std.getName() << Std.getDescription();
             unsigned NumAliases = 0;
 #define LANGSTANDARD(id, name, lang, desc, features)
 #define LANGSTANDARD_ALIAS(id, alias) \
             if (KindValue == LangStandard::lang_##id) ++NumAliases;
 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
 #include "clang/Basic/LangStandards.def"
             Diag << NumAliases;
 #define LANGSTANDARD(id, name, lang, desc, features)
 #define LANGSTANDARD_ALIAS(id, alias) \
             if (KindValue == LangStandard::lang_##id) Diag << alias;
 #define LANGSTANDARD_ALIAS_DEPR(id, alias)
 #include "clang/Basic/LangStandards.def"
           }
         }
-    } else {
+      }
+    } else if (IK.getFormat() != InputKind::Precompiled) {
       // Valid standard, check to make sure language and standard are
       // compatible.
       const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
       if (!IsInputCompatibleWithStandard(IK, Std)) {
         Diags.Report(diag::err_drv_argument_not_allowed_with)
           << A->getAsString(Args) << GetInputKindName(IK);
       }
     }
if (const Arg *A = Args.getLastArg(OPT_sycl_std_EQ)) {
       }
     }
   }
 
   Opts.IncludeDefaultHeader = Args.hasArg(OPT_finclude_default_header);
   Opts.DeclareOpenCLBuiltins = Args.hasArg(OPT_fdeclare_opencl_builtins);
 
   llvm::Triple T(TargetOpts.Triple);
+  if (IK.getFormat() != InputKind::Precompiled &&
+      IK.getLanguage() != Language::LLVM_IR)
     CompilerInvocation::setLangDefaults(Opts, IK, T, PPOpts, LangStd);
 
   // -cl-strict-aliasing needs to emit diagnostic in the case where CL > 1.0.
   // This option should be deprecated for CL > 1.0 because
   // this option was added for compatibility with OpenCL 1.0.
   if (Args.getLastArg(OPT_cl_strict_aliasing)
        && Opts.OpenCLVersion > 100) {
     Diags.Report(diag::warn_option_invalid_ocl_version)
         << Opts.getOpenCLVersionTuple().getAsString()
bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
   InputKind DashX = ParseFrontendArgs(Res.getFrontendOpts(), Args, Diags,
                                       LangOpts.IsHeaderFile);
   ParseTargetArgs(Res.getTargetOpts(), Args, Diags);
   Success &= ParseCodeGenArgs(Res.getCodeGenOpts(), Args, DashX, Diags,
                               Res.getTargetOpts(), Res.getFrontendOpts());
   ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args,
                         Res.getFileSystemOpts().WorkingDir);
   llvm::Triple T(Res.getTargetOpts().Triple);
-  if (DashX.getFormat() == InputKind::Precompiled ||
-      DashX.getLanguage() == Language::LLVM_IR) {
-    // ObjCAAutoRefCount and Sanitize LangOpts are used to setup the
-    // PassManager in BackendUtil.cpp. They need to be initializd no matter
-    // what the input type is.
-    if (Args.hasArg(OPT_fobjc_arc))
-      LangOpts.ObjCAutoRefCount = 1;
-    // PIClevel and PIELevel are needed during code generation and this should be
-    // set regardless of the input type.
-    LangOpts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
-    LangOpts.PIE = Args.hasArg(OPT_pic_is_pie);
-    parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
-                        Diags, LangOpts.Sanitize);
-  } else {
-    // Other LangOpts are only initialized when the input is not AST or LLVM IR.
-    // FIXME: Should we really be calling this for an Language::Asm input?
-    ParseLangArgs(LangOpts, Args, DashX, Res.getTargetOpts(),
-                  Res.getPreprocessorOpts(), Diags);
-    if (Res.getFrontendOpts().ProgramAction == frontend::RewriteObjC)
-      LangOpts.ObjCExceptions = 1;
-    if (T.isOSDarwin() && DashX.isPreprocessed()) {
-      // Supress the darwin-specific 'stdlibcxx-not-found' diagnostic for
-      // preprocessed input as we don't expect it to be used with -std=libc++
-      // anyway.
-      Res.getDiagnosticOpts().Warnings.push_back("no-stdlibcxx-not-found");
-    }
-  }
 
   if (Diags.isIgnored(diag::warn_profile_data_misexpect, SourceLocation()))
     Res.FrontendOpts.LLVMArgs.push_back("-pgo-warn-misexpect");
 
   LangOpts.FunctionAlignment =
       getLastArgIntValue(Args, OPT_function_alignment, 0, Diags);
 
   if (LangOpts.CUDA) {