[clang][cli] Round-trip the whole CompilerInvocation

[jansvoboda11]

Summary

Finally, this patch moves from round-tripping one CompilerInvocation at a time to round-tripping the invocation as a whole.

This patch includes only the code required to make round-tripping the whole invocation work. More cleanups will be done in a follow-up patch.

Depends on D96847, D97041 & D97042.

[dexonsmith]

Mostly looks great; happy to see this come full circle and remove the round-tripping boilerplate. Just a couple of questions inline below.

clang/lib/Frontend/CompilerInvocation.cpp

2005–2008

Was it intentional to comment this out? If so, probably better to delete the line of code.

3516–3518

Was it intentional to comment out this code? If so, probably better to delete it.

4620–4633

This change, like the commented out code I already pointed at, seems not strictly-related to changing round-tripping to happen at a higher level. Is there some reason it's tied to landing at the same time? (If that somehow avoids a bunch of refactoring that'll have to be undone after, fine by me, but otherwise it'd be nice to make this particular patch as clean as possible I think and land the more functional changes ahead of time.)

I also wonder if this special-case logic could/should be buried inside GenerateLangArgs, possibly by passing in DashX as an argument. (Maybe with a FIXME to handle via ShouldParseIf? E.g., maybe almost all lang options could be moved to a let scope that turns on ShouldParseIf with this logic, and these four are left outside of it. Up to you, whether you think that's a good idea.)

[jansvoboda11]

Replace commented-out code with reason behind not generating arguments

[jansvoboda11]

Updated the patch, removed [WIP] from the title and replied to comments.

clang/lib/Frontend/CompilerInvocation.cpp

2005–2008

Yes, it was intentional. I've now replaced the commented-out code with a comment explaining why profile list arguments are not generated here.

3516–3518

Same as above.

4620–4633

This change is necessary for the patch.

Until now, GenerateLangArgs was called (during round-trip) from ParseLangArgs, which is behind the same condition in CreateFromArgs: if (!(DashX.getFormat() == InputKind::Precompiled || DashX.getLanguage() == Language::LLVM_IR)). This change attempts to preserve the previous behavior and also to avoid calling GenerateLangArgs with unexpected/invalid DashX.

I agree eventually moving the logic into {Parse,Generate}LangArgs would be nice, but I'd like to do that in a follow up patch.

[dexonsmith]

LGTM! One more more comment inline.

clang/lib/Frontend/CompilerInvocation.cpp

4620–4633

That makes sense; please add a FIXME to that effect.

[jansvoboda11]

Add fixme as suggested in code review. Rebase on top of the final version of D94472, which added -[no-]round-trip-args. The arguments are now handled in RoundTrip.

[jansvoboda11]

Rebase

[scui]

clang/lib/Frontend/CompilerInvocation.cpp

666

This is failing our build, This line and line 686. The msg is:

llvm-project/clang/lib/Frontend/CompilerInvocation.cpp:666:3: error: too few template arguments for class template 'SmallVector'

SmallVector<const char *> GeneratedArgs1;
^

llvm-project/clang/include/clang/Basic/LLVM.h:35:42: note: template is declared here

template<typename T, unsigned N> class SmallVector;
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~       ^

llvm-project/clang/lib/Frontend/CompilerInvocation.cpp:686:3: error: too few template arguments for class template 'SmallVector'

SmallVector<const char *> GeneratedArgs2;
^

llvm-project/clang/include/clang/Basic/LLVM.h:35:42: note: template is declared here

template<typename T, unsigned N> class SmallVector;
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~       ^

2 errors generated.

[jansvoboda11]

clang/lib/Frontend/CompilerInvocation.cpp

666

That's interesting, the definition of SmallVector defaults N to a sensible number. Out of interest: what compiler are you using?

Should be fixed in 8dc70bdcd0fe4efb65876dce0144d9c3386a2f07.

[scui]

clang/lib/Frontend/CompilerInvocation.cpp

666

Thanks for the quick fix. We are using the IBM XL compilers.

[alanphipps]

We also encounter a build failure on the Mac related to above but in a different file:
clang/lib/CodeGen/CGStmtOpenMP.cpp:1916:3: error: too few template arguments for class template 'SmallVector'
SmallVector<llvm::Value *> EffectiveArgs;
^
clang/include/clang/Basic/LLVM.h:35:42: note: template is declared here
template<typename T, unsigned N> class SmallVector;

[alanphipps]

In D96280#2611651, @alanphipps wrote:

We also encounter a build failure on the Mac related to above but in a different file:
clang/lib/CodeGen/CGStmtOpenMP.cpp:1916:3: error: too few template arguments for class template 'SmallVector'
SmallVector<llvm::Value *> EffectiveArgs;
^
clang/include/clang/Basic/LLVM.h:35:42: note: template is declared here
template<typename T, unsigned N> class SmallVector;

Disregard -- my issue is related to another commit and is addressed by https://reviews.llvm.org/D98265

In D96280#2611651, @alanphipps wrote:

We also encounter a build failure on the Mac related to above but in a different file:
clang/lib/CodeGen/CGStmtOpenMP.cpp:1916:3: error: too few template arguments for class template 'SmallVector'
SmallVector<llvm::Value *> EffectiveArgs;
^
clang/include/clang/Basic/LLVM.h:35:42: note: template is declared here
template<typename T, unsigned N> class SmallVector;

clang/include/clang/Basic/DiagnosticDriverKinds.td

 
 def err_drv_cannot_mix_options : Error<"cannot specify '%1' along with '%0'">;
 
 def err_drv_invalid_object_mode : Error<"OBJECT_MODE setting %0 is not recognized and is not a valid setting.">;
 
 def err_aix_default_altivec_abi : Error<
   "The default Altivec ABI on AIX is not yet supported, use '-mabi=vec-extabi' for the extended Altivec ABI">;
 
-def note_cc1_round_trip_original : Note<"Original arguments in %0 round-trip: %1">;
-def note_cc1_round_trip_generated : Note<"Generated arguments #%1 in %0 round-trip: %2">;
-def remark_cc1_round_trip_generated : Remark<"Generated arguments #%1 in %0 round-trip: %2">, InGroup<RoundTripCC1Args>;
-def err_cc1_round_trip_fail_then_ok : Error<"Original arguments parse failed, then succeeded in %0 round-trip">;
-def err_cc1_round_trip_ok_then_fail : Error<"Generated arguments parse failed in %0 round-trip">;
-def err_cc1_round_trip_mismatch : Error<"Generated arguments do not match in %0 round-trip">;
+def note_cc1_round_trip_original : Note<"Original arguments in round-trip: %0">;
+def note_cc1_round_trip_generated : Note<"Generated arguments #%0 in round-trip: %1">;
+def remark_cc1_round_trip_generated : Remark<"Generated arguments #%0 in round-trip: %1">, InGroup<RoundTripCC1Args>;
+def err_cc1_round_trip_fail_then_ok : Error<"Original arguments parse failed, then succeeded in round-trip">;
+def err_cc1_round_trip_ok_then_fail : Error<"Generated arguments parse failed in round-trip">;
+def err_cc1_round_trip_mismatch : Error<"Generated arguments do not match in round-trip">;
 }

clang/include/clang/Frontend/CompilerInvocation.h

public:
 
   const PreprocessorOutputOptions &getPreprocessorOutputOpts() const {
     return PreprocessorOutputOpts;
   }
 
   /// @}
 
 private:
+  static bool CreateFromArgsImpl(CompilerInvocation &Res,
+                                 ArrayRef<const char *> CommandLineArgs,
+                                 DiagnosticsEngine &Diags, const char *Argv0);
+
   /// Parse command line options from DiagnosticOptions.
   static bool ParseDiagnosticArgsRoundTrip(CompilerInvocation &Res,
                                            DiagnosticOptions &Opts,
                                            llvm::opt::ArgList &Args,
                                            DiagnosticsEngine *Diags = nullptr,
                                            bool DefaultDiagColor = true);
 
   /// Generate command line options from DiagnosticOptions.

clang/lib/Frontend/CompilerInvocation.cpp

[&](const auto &Extracted) {                                               \
                                                           : (DEFAULT_VALUE)))) \
         DENORMALIZER(ARGS, SPELLING, STRING_ALLOCATOR, Option::KIND##Class,    \
                      TABLE_INDEX, Extracted);                                  \
     }(EXTRACTOR(KEYPATH));                                                     \
   }
 
 static const StringRef GetInputKindName(InputKind IK);
 
-static void FixupInvocation(CompilerInvocation &Invocation,
-                            DiagnosticsEngine &Diags, const InputArgList &Args,
+static bool FixupInvocation(CompilerInvocation &Invocation,
+                            DiagnosticsEngine &Diags, const ArgList &Args,
                             InputKind IK) {
+  unsigned NumErrorsBefore = Diags.getNumErrors();
+
   LangOptions &LangOpts = *Invocation.getLangOpts();
   CodeGenOptions &CodeGenOpts = Invocation.getCodeGenOpts();
   TargetOptions &TargetOpts = Invocation.getTargetOpts();
   FrontendOptions &FrontendOpts = Invocation.getFrontendOpts();
   CodeGenOpts.XRayInstrumentFunctions = LangOpts.XRayInstrument;
   CodeGenOpts.XRayAlwaysEmitCustomEvents = LangOpts.XRayAlwaysEmitCustomEvents;
   CodeGenOpts.XRayAlwaysEmitTypedEvents = LangOpts.XRayAlwaysEmitTypedEvents;
   CodeGenOpts.DisableFree = FrontendOpts.DisableFree;
if (emitError)
       Diags.Report(diag::err_drv_argument_not_allowed_with)
           << A->getSpelling() << T.getTriple();
   }
 
   if (!CodeGenOpts.ProfileRemappingFile.empty() && CodeGenOpts.LegacyPassManager)
     Diags.Report(diag::err_drv_argument_only_allowed_with)
         << Args.getLastArg(OPT_fprofile_remapping_file_EQ)->getAsString(Args)
         << "-fno-legacy-pass-manager";
+
+  return Diags.getNumErrors() == NumErrorsBefore;
 }
 
 //===----------------------------------------------------------------------===//
 // Deserialization (from args)
 //===----------------------------------------------------------------------===//
 
 static unsigned getOptimizationLevel(ArgList &Args, InputKind IK,
                                      DiagnosticsEngine &Diags) {
static void GenerateArg(SmallVectorImpl<const char *> &Args,
                         llvm::opt::OptSpecifier OptSpecifier,
                         const Twine &Value,
                         CompilerInvocation::StringAllocator SA) {
   Option Opt = getDriverOptTable().getOption(OptSpecifier);
   denormalizeString(Args, SA(Opt.getPrefix() + Opt.getName()), SA,
                     Opt.getKind(), 0, Value);
 }
 
-// Parse subset of command line arguments into a member of CompilerInvocation.
-using ParseFn = llvm::function_ref<bool(CompilerInvocation &, ArgList &,
-                                        DiagnosticsEngine &)>;
+// Parse command line arguments into CompilerInvocation.
+using ParseFn =
+    llvm::function_ref<bool(CompilerInvocation &, ArrayRef<const char *>,
+                            DiagnosticsEngine &, const char *)>;
 
-// Generate part of command line arguments from a member of CompilerInvocation.
+// Generate command line arguments from CompilerInvocation.
 using GenerateFn = llvm::function_ref<void(
     CompilerInvocation &, SmallVectorImpl<const char *> &,
     CompilerInvocation::StringAllocator)>;
 
-// Swap between dummy/real instance of a CompilerInvocation member.
-using SwapOptsFn = llvm::function_ref<void(CompilerInvocation &)>;
-
-// Performs round-trip of command line arguments if OriginalArgs contain
-// "-round-trip-args". Effectively runs the Parse function for a part of
-// CompilerInvocation on command line arguments that were already once parsed
-// and generated. This is used to check the Generate function produces arguments
-// that are semantically equivalent to those that were used to create
-// CompilerInvocation.
-static bool RoundTrip(ParseFn Parse, GenerateFn Generate, SwapOptsFn SwapOpts,
-                      CompilerInvocation &Res, ArgList &OriginalArgs,
-                      DiagnosticsEngine &Diags, StringRef OptsName) {
+// May perform round-trip of command line arguments. By default, the round-trip
+// is enabled if CLANG_ROUND_TRIP_CC1_ARGS was defined during build. This can be
+// overwritten at run-time via the "-round-trip-args" and "-no-round-trip-args"
+// command line flags.
+// During round-trip, the command line arguments are parsed into a dummy
+// instance of CompilerInvocation which is used to generate the command line
+// arguments again. The real CompilerInvocation instance is then created by
+// parsing the generated arguments, not the original ones.
+static bool RoundTrip(ParseFn Parse, GenerateFn Generate,
+                      CompilerInvocation &RealInvocation,
+                      CompilerInvocation &DummyInvocation,
+                      ArrayRef<const char *> CommandLineArgs,
+                      DiagnosticsEngine &Diags, const char *Argv0) {
   // FIXME: Switch to '#ifndef NDEBUG' when possible.
 #ifdef CLANG_ROUND_TRIP_CC1_ARGS
   bool DoRoundTripDefault = true;
 #else
   bool DoRoundTripDefault = false;
 #endif
 
-  bool DoRoundTrip = OriginalArgs.hasFlag(
-      OPT_round_trip_args, OPT_no_round_trip_args, DoRoundTripDefault);
+  bool DoRoundTrip = DoRoundTripDefault;
+  for (const auto *Arg : CommandLineArgs) {
+    if (Arg == StringRef("-round-trip-args"))
+      DoRoundTrip = true;
+    if (Arg == StringRef("-no-round-trip-args"))
+      DoRoundTrip = false;
+  }
 
-  // If round-trip was not requested, simply run the parser with the original
-  // options and diagnostics.
+  // If round-trip was not requested, simply run the parser with the real
+  // invocation diagnostics.
   if (!DoRoundTrip)
-    return Parse(Res, OriginalArgs, Diags);
+    return Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
 
   // Serializes quoted (and potentially escaped) arguments.
-  auto SerializeArgs = [](ArgStringList &Args) {
+  auto SerializeArgs = [](ArrayRef<const char *> Args) {
     std::string Buffer;
     llvm::raw_string_ostream OS(Buffer);
     for (const char *Arg : Args) {
       llvm::sys::printArg(OS, Arg, /*Quote=*/true);
       OS << ' ';
     }
     OS.flush();
     return Buffer;
   };
 
-  OriginalArgs.clearQueriedOpts();
-
   // Setup a dummy DiagnosticsEngine.
   DiagnosticsEngine DummyDiags(new DiagnosticIDs(), new DiagnosticOptions());
   DummyDiags.setClient(new TextDiagnosticBuffer());
 
-  // Run the first parse on the original arguments with dummy options and
+  // Run the first parse on the original arguments with the dummy invocation and
   // diagnostics.
-  SwapOpts(Res);
-  if (!Parse(Res, OriginalArgs, DummyDiags) ||
+  if (!Parse(DummyInvocation, CommandLineArgs, DummyDiags, Argv0) ||
       DummyDiags.getNumWarnings() != 0) {
     // If the first parse did not succeed, it must be user mistake (invalid
     // command line arguments). We won't be able to generate arguments that
-    // would reproduce the same result. Let's fail again with the original
-    // options and diagnostics, so all side-effects of parsing are visible.
+    // would reproduce the same result. Let's fail again with the real
+    // invocation and diagnostics, so all side-effects of parsing are visible.
     unsigned NumWarningsBefore = Diags.getNumWarnings();
-    SwapOpts(Res);
-    auto Success = Parse(Res, OriginalArgs, Diags);
+    auto Success = Parse(RealInvocation, CommandLineArgs, Diags, Argv0);
     if (!Success || Diags.getNumWarnings() != NumWarningsBefore)
       return Success;
 
     // Parse with original options and diagnostics succeeded even though it
     // shouldn't have. Something is off.
-    Diags.Report(diag::err_cc1_round_trip_fail_then_ok) << OptsName;
-    ArgStringList OriginalStrings;
-    OriginalArgs.AddAllArgsExcept(OriginalStrings, {});
+    Diags.Report(diag::err_cc1_round_trip_fail_then_ok);
     Diags.Report(diag::note_cc1_round_trip_original)
-        << OptsName << SerializeArgs(OriginalStrings);
+        << SerializeArgs(CommandLineArgs);
     return false;
   }
 
   // Setup string allocator.
   llvm::BumpPtrAllocator Alloc;
   llvm::StringSaver StringPool(Alloc);
   auto SA = [&StringPool](const Twine &Arg) {
     return StringPool.save(Arg).data();
   };
 
-  // Generate arguments. First simply copy any arguments the parser did not
-  // query. Then, use the Generate function that uses the CompilerInvocation
-  // options instance as the source of truth. If Generate is the inverse of
-  // Parse, the newly generated arguments must have the same semantics as the
-  // original.
-  ArgStringList GeneratedStrings1;
-  OriginalArgs.AddAllArgsExcept(GeneratedStrings1,
-                                OriginalArgs.getQueriedOpts());
-  Generate(Res, GeneratedStrings1, SA);
-
-  // Process the generated arguments.
-  unsigned MissingArgIndex1, MissingArgCount1;
-  InputArgList GeneratedArgs1 =
-      getDriverOptTable().ParseArgs(GeneratedStrings1, MissingArgIndex1,
-                                    MissingArgCount1, options::CC1Option);
+  // Generate arguments from the dummy invocation. If Generate is the
+  // inverse of Parse, the newly generated arguments must have the same
+  // semantics as the original.
+  SmallVector<const char *> GeneratedArgs1;
+  Generate(DummyInvocation, GeneratedArgs1, SA);
 
-  // TODO: Once we're responsible for generating all arguments, check that we
-  // didn't create any unknown options or omitted required values.
-
-  // Run the second parse, now on the generated arguments, and with the original
-  // options and diagnostics. The result is what we will end up using for the
+  // Run the second parse, now on the generated arguments, and with the real
+  // invocation and diagnostics. The result is what we will end up using for the
   // rest of compilation, so if Generate is not inverse of Parse, something down
   // the line will break.
-  SwapOpts(Res);
-  bool Success2 = Parse(Res, GeneratedArgs1, Diags);
+  bool Success2 = Parse(RealInvocation, GeneratedArgs1, Diags, Argv0);
 
   // The first parse on original arguments succeeded, but second parse of
   // generated arguments failed. Something must be wrong with the generator.
   if (!Success2) {
-    Diags.Report(diag::err_cc1_round_trip_ok_then_fail) << OptsName;
+    Diags.Report(diag::err_cc1_round_trip_ok_then_fail);
     Diags.Report(diag::note_cc1_round_trip_generated)
-        << OptsName << 1 << SerializeArgs(GeneratedStrings1);
+        << 1 << SerializeArgs(GeneratedArgs1);
     return false;
   }
 
   // Generate arguments again, this time from the options we will end up using
   // for the rest of the compilation.
-  ArgStringList GeneratedStrings2;
-  GeneratedArgs1.AddAllArgsExcept(GeneratedStrings2,
-                                  GeneratedArgs1.getQueriedOpts());
-  Generate(Res, GeneratedStrings2, SA);
+  SmallVector<const char *> GeneratedArgs2;
+  Generate(RealInvocation, GeneratedArgs2, SA);
 
   // Compares two lists of generated arguments.
-  auto Equal = [](const ArgStringList &A, const ArgStringList &B) {
+  auto Equal = [](const ArrayRef<const char *> A,
+                  const ArrayRef<const char *> B) {
     return std::equal(A.begin(), A.end(), B.begin(), B.end(),
                       [](const char *AElem, const char *BElem) {
                         return StringRef(AElem) == StringRef(BElem);
                       });
   };
 
   // If we generated different arguments from what we assume are two
   // semantically equivalent CompilerInvocations, the Generate function may
   // be non-deterministic.
-  if (!Equal(GeneratedStrings1, GeneratedStrings2)) {
-    Diags.Report(diag::err_cc1_round_trip_mismatch) << OptsName;
+  if (!Equal(GeneratedArgs1, GeneratedArgs2)) {
+    Diags.Report(diag::err_cc1_round_trip_mismatch);
     Diags.Report(diag::note_cc1_round_trip_generated)
-        << OptsName << 1 << SerializeArgs(GeneratedStrings1);
+        << 1 << SerializeArgs(GeneratedArgs1);
     Diags.Report(diag::note_cc1_round_trip_generated)
-        << OptsName << 2 << SerializeArgs(GeneratedStrings2);
+        << 2 << SerializeArgs(GeneratedArgs2);
     return false;
   }
 
   Diags.Report(diag::remark_cc1_round_trip_generated)
-      << OptsName << 1 << SerializeArgs(GeneratedStrings1);
+      << 1 << SerializeArgs(GeneratedArgs1);
   Diags.Report(diag::remark_cc1_round_trip_generated)
-      << OptsName << 2 << SerializeArgs(GeneratedStrings2);
+      << 2 << SerializeArgs(GeneratedArgs2);
 
   return Success2;
 }
 
 static void addDiagnosticArgs(ArgList &Args, OptSpecifier Group,
                               OptSpecifier GroupWithValue,
                               std::vector<std::string> &Diagnostics) {
   for (auto *A : Args.filtered(Group)) {
#include "clang/StaticAnalyzer/Core/Analyses.def"
   }
   os.flush();
 
   return Success;
 }
 
 static bool ParseAnalyzerArgs(CompilerInvocation &Res, AnalyzerOptions &Opts,
                               ArgList &Args, DiagnosticsEngine &Diags) {
-  auto DummyOpts = IntrusiveRefCntPtr<AnalyzerOptions>(new AnalyzerOptions());
-
-  return RoundTrip(
-      [](CompilerInvocation &Res, ArgList &Args, DiagnosticsEngine &Diags) {
-        return ParseAnalyzerArgsImpl(*Res.getAnalyzerOpts(), Args, Diags);
-      },
-      [](CompilerInvocation &Res, SmallVectorImpl<const char *> &Args,
-         CompilerInvocation::StringAllocator SA) {
-        GenerateAnalyzerArgs(*Res.getAnalyzerOpts(), Args, SA);
-      },
-      [&DummyOpts](CompilerInvocation &Res) {
-        Res.getAnalyzerOpts().swap(DummyOpts);
-      },
-      Res, Args, Diags, "AnalyzerOptions");
 }
 
 static StringRef getStringOption(AnalyzerOptions::ConfigTable &Config,
                                  StringRef OptionName, StringRef DefaultVal) {
   return Config.insert({OptionName, std::string(DefaultVal)}).first->second;
 }
 
 static void initOption(AnalyzerOptions::ConfigTable &Config,
if (Opts.MemoryProfileOutput == MemProfileBasename) {
       size_t ArgLength =
           Opts.MemoryProfileOutput.size() - MemProfileBasename.size();
       GenerateArg(Args, OPT_fmemory_profile_EQ,
                   Opts.MemoryProfileOutput.substr(0, ArgLength), SA);
     }
   }
 
   if (memcmp(Opts.CoverageVersion, "408*", 4) != 0)
-    GenerateArg(Args, OPT_coverage_version_EQ, Opts.CoverageVersion, SA);
+    GenerateArg(Args, OPT_coverage_version_EQ,
+                StringRef(Opts.CoverageVersion, 4), SA);
 
   // TODO: Check if we need to generate arguments stored in CmdArgs. (Namely
   //  '-fembed_bitcode', which does not map to any CompilerInvocation field and
   //  won't be generated.)
 
   if (Opts.XRayInstrumentationBundle.Mask != XRayInstrKind::All) {
     std::string InstrBundle =
         serializeXRayInstrumentationBundle(Opts.XRayInstrumentationBundle);
#undef CODEGEN_OPTION_WITH_MARSHALLING
 
   return Success && Diags.getNumErrors() == NumErrorsBefore;
 }
 
 bool CompilerInvocation::ParseCodeGenArgs(
     CompilerInvocation &Res, CodeGenOptions &Opts, ArgList &Args, InputKind IK,
     DiagnosticsEngine &Diags, const llvm::Triple &T,
     const std::string &OutputFile, const LangOptions &LangOptsRef) {
-  CodeGenOptions DummyOpts;
-
-  return RoundTrip(
-      [&](CompilerInvocation &Res, ArgList &Args, DiagnosticsEngine &Diags) {
-        Args.getLastArg(OPT_O0, OPT_O4, OPT_O, OPT_Ofast);
-        return ParseCodeGenArgsImpl(Res.getCodeGenOpts(), Args, IK, Diags, T,
-                                    OutputFile, LangOptsRef);
-      },
-      [&](CompilerInvocation &Res, SmallVectorImpl<const char *> &GeneratedArgs,
-          StringAllocator SA) {
-        GenerateCodeGenArgs(Res.getCodeGenOpts(), GeneratedArgs, SA, T,
-                            OutputFile, &LangOptsRef);
-      },
-      [&DummyOpts](CompilerInvocation &Res) {
-        std::swap(Res.CodeGenOpts, DummyOpts);
-      },
-      Res, Args, Diags, "CodeGenOptions");
 }
 
 static void
 GenerateDependencyOutputArgs(const DependencyOutputOptions &Opts,
                              SmallVectorImpl<const char *> &Args,
                              CompilerInvocation::StringAllocator SA) {
   const DependencyOutputOptions &DependencyOutputOpts = Opts;
 #define DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING(                             \
for (const auto &Dep : Opts.ExtraDeps) {
     switch (Dep.second) {
     case EDK_SanitizeBlacklist:
       // Sanitizer blacklist arguments are generated from LanguageOptions.
       continue;
     case EDK_ModuleFile:
       // Module file arguments are generated from FrontendOptions and
       // HeaderSearchOptions.
       continue;
     case EDK_ProfileList:
-      GenerateArg(Args, OPT_fprofile_list_EQ, Dep.first, SA);
-      break;
+      // Profile list arguments are generated from LanguageOptions via the
+      // marshalling infrastructure.
+      continue;
     case EDK_DepFileEntry:
       GenerateArg(Args, OPT_fdepfile_entry, Dep.first, SA);
       break;
     }
   }
 }
 
 static bool ParseDependencyOutputArgsImpl(
#undef DEPENDENCY_OUTPUT_OPTION_WITH_MARSHALLING
   return Success && Diags.getNumErrors() == NumErrorsBefore;
 }
 
 static bool ParseDependencyOutputArgs(CompilerInvocation &Res,
                                       DependencyOutputOptions &Opts,
                                       ArgList &Args, DiagnosticsEngine &Diags,
                                       frontend::ActionKind Action,
                                       bool ShowLineMarkers) {
-  DependencyOutputOptions DummyOpts;
-
-  return RoundTrip(
-      [Action, ShowLineMarkers](CompilerInvocation &Res, ArgList &Args,
-                                DiagnosticsEngine &Diags) {
-        return ParseDependencyOutputArgsImpl(Res.getDependencyOutputOpts(),
-                                             Args, Diags, Action,
-                                             ShowLineMarkers);
-      },
-      [&Args](CompilerInvocation &Res,
-              SmallVectorImpl<const char *> &GeneratedArgs,
-              CompilerInvocation::StringAllocator SA) {
-        GenerateDependencyOutputArgs(Res.getDependencyOutputOpts(),
-                                     GeneratedArgs, SA);
-        // We're querying sanitizer blacklist and module file arguments, but
-        // they are generated from LanguageOptions and HeaderSearchOptions.
-        // Let's satisfy RoundTrip by generating them ourselves for now.
-        if (!Args.hasArg(OPT_fno_sanitize_blacklist)) {
-          for (const auto *A : Args.filtered(OPT_fsanitize_blacklist)) {
-            StringRef Val = A->getValue();
-            if (Val.find('=') == StringRef::npos)
-              GenerateArg(GeneratedArgs, OPT_fsanitize_blacklist, Val, SA);
-          }
-          if (Res.getDependencyOutputOpts().IncludeSystemHeaders) {
-            for (const auto *A :
-                 Args.filtered(OPT_fsanitize_system_blacklist)) {
-              StringRef Val = A->getValue();
-              if (Val.find('=') == StringRef::npos)
-                GenerateArg(GeneratedArgs, OPT_fsanitize_system_blacklist, Val,
-                            SA);
-            }
-          }
-        }
-
-        for (const auto *A : Args.filtered(OPT_fmodule_file)) {
-          StringRef Val = A->getValue();
-          if (Val.find('=') == StringRef::npos)
-            GenerateArg(GeneratedArgs, OPT_fmodule_file, Val, SA);
-        }
-      },
-      [&DummyOpts](CompilerInvocation &Res) {
-        std::swap(Res.getDependencyOutputOpts(), DummyOpts);
-      },
-      Res, Args, Diags, "DependencyOutputOptions");
+  return ParseDependencyOutputArgsImpl(Res.getDependencyOutputOpts(), Args,
+                                       Diags, Action, ShowLineMarkers);
 }
 
 static bool parseShowColorsArgs(const ArgList &Args, bool DefaultColor) {
   // Color diagnostics default to auto ("on" if terminal supports) in the driver
   // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
   // Support both clang's -f[no-]color-diagnostics and gcc's
   // -f[no-]diagnostics-colors[=never|always|auto].
   enum {
#undef DIAG_OPTION_WITH_MARSHALLING
   return Success;
 }
 
 bool CompilerInvocation::ParseDiagnosticArgsRoundTrip(CompilerInvocation &Res,
                                                       DiagnosticOptions &Opts,
                                                       ArgList &Args,
                                                       DiagnosticsEngine *Diags,
                                                       bool DefaultDiagColor) {
-  IntrusiveRefCntPtr<DiagnosticOptions> DummyOpts(new DiagnosticOptions);
-
-  return RoundTrip(
-      [DefaultDiagColor](CompilerInvocation &Res, ArgList &Args,
-                         DiagnosticsEngine &Diags) {
-        // Query the options might not get queried properly during parsing, but
-        // should be generated from DiagnosticOptions.
-
-        Args.getLastArg(OPT_fcolor_diagnostics);
-        Args.getLastArg(OPT_fno_color_diagnostics);
-        Args.getLastArg(OPT_fdiagnostics_color);
-        Args.getLastArg(OPT_fno_diagnostics_color);
-        Args.getLastArg(OPT_fdiagnostics_color_EQ);
-
-        for (auto *A : Args.filtered(OPT_W_Group))
-          Args.getLastArg(A->getOption().getID());
-        for (auto *A : Args.filtered(OPT_R_Group))
-          Args.getLastArg(A->getOption().getID());
-
-        return clang::ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, &Diags,
-                                          DefaultDiagColor);
-      },
-      [DefaultDiagColor](CompilerInvocation &Res,
-                         SmallVectorImpl<const char *> &Args,
-                         CompilerInvocation::StringAllocator SA) {
-        GenerateDiagnosticArgs(Res.getDiagnosticOpts(), Args, SA,
+  return clang::ParseDiagnosticArgs(Res.getDiagnosticOpts(), Args, Diags,
                                     DefaultDiagColor);
-      },
-      [&DummyOpts](CompilerInvocation &Res) {
-        Res.DiagnosticOpts.swap(DummyOpts);
-      },
-      Res, Args, *Diags, "DiagnosticOptions");
 }
 
 /// Parse the argument to the -ftest-module-file-extension
 /// command-line argument.
 ///
 /// \returns true on error, false on success.
 static bool parseTestModuleFileExtensionArg(StringRef Arg,
                                             std::string &BlockName,
#undef FRONTEND_OPTION_WITH_MARSHALLING
   Opts.DashX = DashX;
 
   return Diags.getNumErrors() == NumErrorsBefore;
 }
 
 static bool ParseFrontendArgs(CompilerInvocation &Res, FrontendOptions &Opts,
                               ArgList &Args, DiagnosticsEngine &Diags,
                               bool &IsHeaderFile) {
-  FrontendOptions DummyOpts;
-
-  return RoundTrip(
-      [&IsHeaderFile](CompilerInvocation &Res, ArgList &Args,
-                      DiagnosticsEngine &Diags) {
-        // ParseFrontendArgsImpl handles frontend action without querying the
-        // options. Let's do it now so RoundTrip considers us responsible for
-        // generating it.
-        for (const auto &Pair : getFrontendActionTable())
-          Args.hasArg(Pair.second);
-
-        return ParseFrontendArgsImpl(Res.getFrontendOpts(), Args, Diags,
-                                     IsHeaderFile);
-      },
-      [&IsHeaderFile](CompilerInvocation &Res,
-                      SmallVectorImpl<const char *> &Args,
-                      CompilerInvocation::StringAllocator SA) {
-        GenerateFrontendArgs(Res.getFrontendOpts(), Args, SA, IsHeaderFile);
-      },
-      [&DummyOpts](CompilerInvocation &Res) {
-        std::swap(Res.getFrontendOpts(), DummyOpts);
-      },
-      Res, Args, Diags, "FrontendOptions");
 }
 
 std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
                                                  void *MainAddr) {
   std::string ClangExecutable =
       llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
   return Driver::GetResourcesPath(ClangExecutable, CLANG_RESOURCE_DIR);
 }
#undef HEADER_SEARCH_OPTION_WITH_MARSHALLING
   return Success;
 }
 
 void CompilerInvocation::ParseHeaderSearchArgs(CompilerInvocation &Res,
                                                HeaderSearchOptions &Opts,
                                                ArgList &Args,
                                                DiagnosticsEngine &Diags,
                                                const std::string &WorkingDir) {
-  auto DummyOpts = std::make_shared<HeaderSearchOptions>();
-
-  RoundTrip(
-      [&WorkingDir](CompilerInvocation &Res, ArgList &Args,
-                    DiagnosticsEngine &Diags) {
-        return ::ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args, Diags,
-                                       WorkingDir);
-      },
-      [](CompilerInvocation &Res, SmallVectorImpl<const char *> &GeneratedArgs,
-         CompilerInvocation::StringAllocator SA) {
-        GenerateHeaderSearchArgs(Res.getHeaderSearchOpts(), GeneratedArgs, SA);
-      },
-      [&DummyOpts](CompilerInvocation &Res) {
-        Res.HeaderSearchOpts.swap(DummyOpts);
-      },
-      Res, Args, Diags, "HeaderSearchOptions");
+  ::ParseHeaderSearchArgs(Res.getHeaderSearchOpts(), Args, Diags, WorkingDir);
 }
 
 void CompilerInvocation::setLangDefaults(LangOptions &Opts, InputKind IK,
                                          const llvm::Triple &T,
                                          std::vector<std::string> &Includes,
                                          LangStandard::Kind LangStd) {
   // Set some properties which depend solely on the input kind; it would be nice
   // to move these to the language standard, and have the driver resolve the
if (Opts.OpenMPCUDAMode)
     GenerateArg(Args, OPT_fopenmp_cuda_mode, SA);
 
   if (Opts.OpenMPCUDATargetParallel)
     GenerateArg(Args, OPT_fopenmp_cuda_parallel_target_regions, SA);
 
   if (Opts.OpenMPCUDAForceFullRuntime)
     GenerateArg(Args, OPT_fopenmp_cuda_force_full_runtime, SA);
 
-  // The arguments used to set 'Optimize' and 'OptimizeSize' will be generated
-  // by CodeGenOptions.
-
-  if (Opts.NoInlineDefine && Opts.Optimize)
-    GenerateArg(Args, OPT_fno_inline, SA);
+  // The arguments used to set Optimize, OptimizeSize and NoInlineDefine are
+  // generated from CodeGenOptions.
 
   if (Opts.DefaultFPContractMode == LangOptions::FPM_Fast)
     GenerateArg(Args, OPT_ffp_contract, "fast", SA);
   else if (Opts.DefaultFPContractMode == LangOptions::FPM_On)
     GenerateArg(Args, OPT_ffp_contract, "on", SA);
   else if (Opts.DefaultFPContractMode == LangOptions::FPM_Off)
     GenerateArg(Args, OPT_ffp_contract, "off", SA);
   else if (Opts.DefaultFPContractMode == LangOptions::FPM_FastHonorPragmas)
     GenerateArg(Args, OPT_ffp_contract, "fast-honor-pragmas", SA);

 }
 
 bool CompilerInvocation::ParseLangArgs(CompilerInvocation &Res,
                                        LangOptions &Opts,
                                        llvm::opt::ArgList &Args, InputKind IK,
                                        const llvm::Triple &T,
                                        std::vector<std::string> &Includes,
                                        DiagnosticsEngine &Diags) {
-  auto DummyOpts = std::make_shared<LangOptions>();
-
-  // We need to work around inconsistencies related to optimization flags. Their
-  // primary consumer is CodeGenOptions. However, the LangOptions parser also
-  // queries them, which means RoundTrip expects us to generate them. We don't
-  // want to do it in GenerateLangArgs, because it should eventually be the
-  // responsibility of GenerateCodeGenArgs. Until we start doing one big
-  // round-trip, let's do it here.
-  //
-  // Our parser always queries OPT_O_Group. When given -O1, -O2 or -O3, it also
-  // queries OPT_O. To ensure RoundTrip consistently considers us responsible
-  // for generating all of them, we ensure to proactively query them all.
-
-  return RoundTrip(
-      [IK, &T, &Includes](CompilerInvocation &Res, ArgList &Args,
-                          DiagnosticsEngine &Diags) {
-        // Proactively query all optimization flags.
-        Args.getLastArg(OPT_O0, OPT_O4, OPT_O, OPT_Ofast);
-        return ParseLangArgsImpl(*Res.getLangOpts(), Args, IK, T, Includes,
-                                 Diags);
-      },
-      [&T, &Args](CompilerInvocation &Res,
-                  SmallVectorImpl<const char *> &GenArgs, StringAllocator SA) {
-        GenerateLangArgs(*Res.getLangOpts(), GenArgs, SA, T);
-        // Generate all optimization flags we queried.
-        if (Arg *A = Args.getLastArg(OPT_O_Group)) {
-          OptSpecifier Opt = A->getOption().getID();
-
-          if (A->getNumValues() > 0)
-            GenerateArg(GenArgs, Opt, A->getValues().back(), SA);
-          else
-            GenerateArg(GenArgs, Opt, SA);
-        }
-
-        // We also queried -fcf-protection, but don't have enough information to
-        // generate it. Eventually, it will be generated from CodeGenOptions.
-        if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ))
-          GenerateArg(GenArgs, OPT_fcf_protection_EQ, A->getValue(), SA);
-      },
-      [&DummyOpts](CompilerInvocation &Res) { Res.LangOpts.swap(DummyOpts); },
-      Res, Args, Diags, "LangOptions");
+  return ParseLangArgsImpl(*Res.getLangOpts(), Args, IK, T, Includes, Diags);
 }
 
 static bool isStrictlyPreprocessorAction(frontend::ActionKind Action) {
   switch (Action) {
   case frontend::ASTDeclList:
   case frontend::ASTDump:
   case frontend::ASTPrint:
   case frontend::ASTView:
#undef PREPROCESSOR_OPTION_WITH_MARSHALLING
   return Success;
 }
 
 static bool ParsePreprocessorArgs(CompilerInvocation &Res,
                                   PreprocessorOptions &Opts, ArgList &Args,
                                   DiagnosticsEngine &Diags,
                                   frontend::ActionKind Action,
                                   FrontendOptions &FrontendOpts) {
-  auto DummyOpts = std::make_shared<PreprocessorOptions>();
-
-  auto Parse = [Action](CompilerInvocation &Res, ArgList &Args,
-                        DiagnosticsEngine &Diags) {
-    return ParsePreprocessorArgsImpl(Res.getPreprocessorOpts(), Args, Diags,
-                                     Action, Res.getFrontendOpts());
-  };
-
-  auto Generate = [&Args](CompilerInvocation &Res,
-                     SmallVectorImpl<const char *> &GeneratedArgs,
-                     CompilerInvocation::StringAllocator SA) {
-    GeneratePreprocessorArgs(Res.getPreprocessorOpts(), GeneratedArgs, SA,
-                             *Res.getLangOpts(), Res.getFrontendOpts(),
-                             Res.getCodeGenOpts());
-    // The ParsePreprocessorArgs function queries the -fcf-protection option,
-    // which means that it won't be directly copied during argument generation.
-    // The GeneratePreprocessorArgs function isn't responsible for generating it
-    // either. This would cause -fcf-protection to get forgotten during
-    // round-trip and the __CET__ macros wouldn't get deduced during second call
-    // to ParsePreprocessorArgs. Let's fix this by generating -fcf-protection
-    // here.
-    // TODO: Remove this once we're doing one big round-trip instead of many
-    // small ones.
-    if (const Arg *A = Args.getLastArg(OPT_fcf_protection_EQ))
-      GenerateArg(GeneratedArgs, OPT_fcf_protection_EQ, A->getValue(), SA);
-  };
-
-  auto Swap = [&DummyOpts](CompilerInvocation &Res) {
-    std::swap(Res.PreprocessorOpts, DummyOpts);
-  };
-
-  return RoundTrip(Parse, Generate, Swap, Res, Args, Diags,
-                   "PreprocessorOptions");
 }
 
 static void GeneratePreprocessorOutputArgs(
     const PreprocessorOutputOptions &Opts, SmallVectorImpl<const char *> &Args,
     CompilerInvocation::StringAllocator SA, frontend::ActionKind Action) {
   const PreprocessorOutputOptions &PreprocessorOutputOpts = Opts;
 
 #define PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING(                           \
#undef PREPROCESSOR_OUTPUT_OPTION_WITH_MARSHALLING
 
   return Success && Diags.getNumErrors() == NumErrorsBefore;
 }
 
 static bool ParsePreprocessorOutputArgs(CompilerInvocation &Res,
                                         PreprocessorOutputOptions &Opts,
                                         ArgList &Args, DiagnosticsEngine &Diags,
                                         frontend::ActionKind Action) {
-  PreprocessorOutputOptions DummyOpts;
-
-  return RoundTrip(
-      [Action](CompilerInvocation &Res, ArgList &Args,
-               DiagnosticsEngine &Diags) {
-        return ParsePreprocessorOutputArgsImpl(Res.getPreprocessorOutputOpts(),
-                                               Args, Diags, Action);
-      },
-      [Action](CompilerInvocation &Res, SmallVectorImpl<const char *> &Args,
-               CompilerInvocation::StringAllocator SA) {
-        GeneratePreprocessorOutputArgs(Res.getPreprocessorOutputOpts(), Args,
-                                       SA, Action);
-      },
-      [&DummyOpts](CompilerInvocation &Res) {
-        std::swap(DummyOpts, Res.getPreprocessorOutputOpts());
-      },
-      Res, Args, Diags, "PreprocessorOutputOptions");
+  return ParsePreprocessorOutputArgsImpl(Res.getPreprocessorOutputOpts(), Args,
+                                         Diags, Action);
 }
 
 static void GenerateTargetArgs(const TargetOptions &Opts,
                                SmallVectorImpl<const char *> &Args,
                                CompilerInvocation::StringAllocator SA) {
   const TargetOptions *TargetOpts = &Opts;
 #define TARGET_OPTION_WITH_MARSHALLING(                                        \
     PREFIX_TYPE, NAME, ID, KIND, GROUP, ALIAS, ALIASARGS, FLAGS, PARAM,        \
else
       Opts.SDKVersion = Version;
   }
 
   return Success && Diags.getNumErrors() == NumErrorsBefore;
 }
 
 static bool ParseTargetArgs(CompilerInvocation &Res, TargetOptions &Opts,
                             ArgList &Args, DiagnosticsEngine &Diags) {
-  auto DummyOpts = std::make_shared<TargetOptions>();
-
-  return RoundTrip(
-      [](CompilerInvocation &Res, ArgList &Args,
-                    DiagnosticsEngine &Diags) {
-        return ParseTargetArgsImpl(Res.getTargetOpts(), Args, Diags);
-      },
-      [](CompilerInvocation &Res, SmallVectorImpl<const char *> &GeneratedArgs,
-         CompilerInvocation::StringAllocator SA) {
-        GenerateTargetArgs(Res.getTargetOpts(), GeneratedArgs, SA);
-      },
-      [&DummyOpts](CompilerInvocation &Res) {
-        Res.TargetOpts.swap(DummyOpts);
-      },
-      Res, Args, Diags, "TargetArgs");
 }
 
-bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
-                                        ArrayRef<const char *> CommandLineArgs,
-                                        DiagnosticsEngine &Diags,
-                                        const char *Argv0) {
+bool CompilerInvocation::CreateFromArgsImpl(
+    CompilerInvocation &Res, ArrayRef<const char *> CommandLineArgs,
+    DiagnosticsEngine &Diags, const char *Argv0) {
   bool Success = true;
 
   // Parse the arguments.
   const OptTable &Opts = getDriverOptTable();
   const unsigned IncludedFlagsBitmask = options::CC1Option;
   unsigned MissingArgIndex, MissingArgCount;
   InputArgList Args = Opts.ParseArgs(CommandLineArgs, MissingArgIndex,
                                      MissingArgCount, IncludedFlagsBitmask);
bool CompilerInvocation::CreateFromArgsImpl(
   Success &= ParseAnalyzerArgs(Res, *Res.getAnalyzerOpts(), Args, Diags);
   Success &=
       ParseDiagnosticArgsRoundTrip(Res, Res.getDiagnosticOpts(), Args, &Diags,
                                    /*DefaultDiagColor=*/false);
   Success &= ParseFrontendArgs(Res, Res.getFrontendOpts(), Args, Diags,
                                LangOpts.IsHeaderFile);
   // FIXME: We shouldn't have to pass the DashX option around here
   InputKind DashX = Res.getFrontendOpts().DashX;
-  ParseTargetArgs(Res, Res.getTargetOpts(), Args, Diags);
+  Success &= ParseTargetArgs(Res, Res.getTargetOpts(), Args, Diags);
   llvm::Triple T(Res.getTargetOpts().Triple);
   ParseHeaderSearchArgs(Res, Res.getHeaderSearchOpts(), Args, Diags,
                         Res.getFileSystemOpts().WorkingDir);
   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 (Res.getCodeGenOpts().FineGrainedBitfieldAccesses &&
     Res.getCodeGenOpts().FineGrainedBitfieldAccesses = false;
     Diags.Report(diag::warn_drv_fine_grained_bitfield_accesses_ignored);
   }
 
   // Store the command-line for using in the CodeView backend.
   Res.getCodeGenOpts().Argv0 = Argv0;
   Res.getCodeGenOpts().CommandLineArgs = CommandLineArgs;
 
-  FixupInvocation(Res, Diags, Args, DashX);
+  Success &= FixupInvocation(Res, Diags, Args, DashX);
 
   return Success;
 }
 
+bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Invocation,
+                                        ArrayRef<const char *> CommandLineArgs,
+                                        DiagnosticsEngine &Diags,
+                                        const char *Argv0) {
+  CompilerInvocation DummyInvocation;
+
+  return RoundTrip(
+      [](CompilerInvocation &Invocation, ArrayRef<const char *> CommandLineArgs,
+         DiagnosticsEngine &Diags, const char *Argv0) {
+        return CreateFromArgsImpl(Invocation, CommandLineArgs, Diags, Argv0);
+      },
+      [](CompilerInvocation &Invocation, SmallVectorImpl<const char *> &Args,
+         StringAllocator SA) { Invocation.generateCC1CommandLine(Args, SA); },
+      Invocation, DummyInvocation, CommandLineArgs, Diags, Argv0);
+}
+
 std::string CompilerInvocation::getModuleHash() const {
   // Note: For QoI reasons, the things we use as a hash here should all be
   // dumped via the -module-info flag.
   using llvm::hash_code;
   using llvm::hash_value;
   using llvm::hash_combine;
   using llvm::hash_combine_range;
 
if (!hsOpts.ModulesIgnoreMacros.empty()) {
       if (hsOpts.ModulesIgnoreMacros.count(
               llvm::CachedHashString(MacroDef.split('=').first)))
         continue;
     }
 
     code = hash_combine(code, I.first, I.second);
   }
 
   // Extend the signature with the sysroot and other header search options.
   code = hash_combine(code, hsOpts.Sysroot,
                       hsOpts.ModuleFormat,
                       hsOpts.UseDebugInfo,
                       hsOpts.UseBuiltinIncludes,
                       hsOpts.UseStandardSystemIncludes,
                       hsOpts.UseStandardCXXIncludes,
                       hsOpts.UseLibcxx,
                       hsOpts.ModulesValidateDiagnosticOptions);
   code = hash_combine(code, hsOpts.ResourceDir);
void CompilerInvocation::generateCC1CommandLine(
 
   GenerateFileSystemArgs(FileSystemOpts, Args, SA);
   GenerateMigratorArgs(MigratorOpts, Args, SA);
   GenerateAnalyzerArgs(*AnalyzerOpts, Args, SA);
   GenerateDiagnosticArgs(*DiagnosticOpts, Args, SA, false, T, DashX);
   GenerateFrontendArgs(FrontendOpts, Args, SA, LangOpts->IsHeaderFile);
   GenerateTargetArgs(*TargetOpts, Args, SA);
   GenerateHeaderSearchArgs(*HeaderSearchOpts, Args, SA);
+
+  if (DashX.getFormat() == InputKind::Precompiled ||
+      DashX.getLanguage() == Language::LLVM_IR) {
+    if (LangOpts->ObjCAutoRefCount)
+      GenerateArg(Args, OPT_fobjc_arc, SA);
+    if (LangOpts->PICLevel != 0)
+      GenerateArg(Args, OPT_pic_level, Twine(LangOpts->PICLevel), SA);
+    if (LangOpts->PIE)
+      GenerateArg(Args, OPT_pic_is_pie, SA);
+    for (StringRef Sanitizer : serializeSanitizerKinds(LangOpts->Sanitize))
+      GenerateArg(Args, OPT_fsanitize_EQ, Sanitizer, SA);
+  } else {
+    // FIXME: Move this whole condition into GenerateLangArgs. (And do the same
+    // for ParseLangArgs).
     GenerateLangArgs(*LangOpts, Args, SA, T);
+  }
+
   GenerateCodeGenArgs(CodeGenOpts, Args, SA, T, FrontendOpts.OutputFile,
                       &*LangOpts);
   GeneratePreprocessorArgs(*PreprocessorOpts, Args, SA, *LangOpts, FrontendOpts,
                            CodeGenOpts);
   GeneratePreprocessorOutputArgs(PreprocessorOutputOpts, Args, SA,
                                  FrontendOpts.ProgramAction);
   GenerateDependencyOutputArgs(DependencyOutputOpts, Args, SA);
 }

clang/test/Frontend/round-trip-cc1-args.c

 // RUN: %clang_cc1 %s -no-round-trip-args -Rround-trip-cc1-args 2>&1 | FileCheck %s -check-prefix=CHECK-WITHOUT-ROUND-TRIP -allow-empty
 // RUN: %clang_cc1 %s -round-trip-args 2>&1 | FileCheck %s -check-prefix=CHECK-ROUND-TRIP-WITHOUT-REMARKS -allow-empty
 // RUN: %clang_cc1 %s -round-trip-args -Rround-trip-cc1-args 2>&1 | FileCheck %s -check-prefix=CHECK-ROUND-TRIP-WITH-REMARKS
 
 // CHECK-WITHOUT-ROUND-TRIP-NOT: remark:
 // CHECK-ROUND-TRIP-WITHOUT-REMARKS-NOT: remark:
-// CHECK-ROUND-TRIP-WITH-REMARKS: remark: Generated arguments {{.*}} in {{.*}} round-trip: {{.*}}
+// CHECK-ROUND-TRIP-WITH-REMARKS: remark: Generated arguments #{{.*}} in round-trip: {{.*}}