Re-use a single SmallString instance to reduce the stack frame size

[djasper]

Summary

In certain builds (msan), this can otherwise exceed the stack frame limit set for certain environments.

[klimek]

lg

[djasper]

Submitted as r241894.

lib/Driver/Tools.cpp

auto *ProfileUseArg = Args.getLastArg(
       options::OPT_fprofile_instr_use, options::OPT_fprofile_instr_use_EQ,
       options::OPT_fprofile_use, options::OPT_fprofile_use_EQ);
 
   if (ProfileGenerateArg && ProfileUseArg)
     D.Diag(diag::err_drv_argument_not_allowed_with)
         << ProfileGenerateArg->getSpelling()
         << ProfileUseArg->getSpelling();
 
+  SmallString<128> Path;
   if (ProfileGenerateArg &&
       ProfileGenerateArg->getOption().matches(
           options::OPT_fprofile_instr_generate_EQ))
     ProfileGenerateArg->render(Args, CmdArgs);
   else if (ProfileGenerateArg &&
            ProfileGenerateArg->getOption().matches(
                options::OPT_fprofile_generate_EQ)) {
-    SmallString<128> Path(ProfileGenerateArg->getValue());
+    Path = ProfileGenerateArg->getValue();
     llvm::sys::path::append(Path, "default.profraw");
     CmdArgs.push_back(
         Args.MakeArgString(Twine("-fprofile-instr-generate=") + Path));
   } else
     Args.AddAllArgs(CmdArgs, options::OPT_fprofile_instr_generate);
 
   if (ProfileUseArg &&
       ProfileUseArg->getOption().matches(options::OPT_fprofile_instr_use_EQ))
     ProfileUseArg->render(Args, CmdArgs);
   else if (ProfileUseArg &&
            (ProfileUseArg->getOption().matches(options::OPT_fprofile_use_EQ) ||
             ProfileUseArg->getOption().matches(
                 options::OPT_fprofile_instr_use))) {
-    SmallString<128> Path(
-        ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue());
+    Path = ProfileUseArg->getNumValues() == 0 ? "" : ProfileUseArg->getValue();
     if (Path.empty() || llvm::sys::fs::is_directory(Path))
       llvm::sys::path::append(Path, "default.profdata");
     CmdArgs.push_back(Args.MakeArgString(Twine("-fprofile-instr-use=") + Path));
   }
 
   if (Args.hasArg(options::OPT_ftest_coverage) ||
       Args.hasArg(options::OPT_coverage))
     CmdArgs.push_back("-femit-coverage-notes");
if (Output.isFilename()) {
       CmdArgs.push_back("-coverage-file");
       SmallString<128> CoverageFilename;
       if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o)) {
         CoverageFilename = FinalOutput->getValue();
       } else {
         CoverageFilename = llvm::sys::path::filename(Output.getBaseInput());
       }
       if (llvm::sys::path::is_relative(CoverageFilename)) {
-        SmallString<128> Pwd;
-        if (!llvm::sys::fs::current_path(Pwd)) {
-          llvm::sys::path::append(Pwd, CoverageFilename);
-          CoverageFilename.swap(Pwd);
+        if (!llvm::sys::fs::current_path(Path)) {
+          llvm::sys::path::append(Path, CoverageFilename);
+          CoverageFilename.swap(Path);
         }
       }
       CmdArgs.push_back(Args.MakeArgString(CoverageFilename));
     }
   }
 
   // Pass options for controlling the default header search paths.
   if (Args.hasArg(options::OPT_nostdinc)) {

   // definitions.
   Args.AddAllArgs(CmdArgs, options::OPT_fmodule_map_file);
 
   // -fmodule-file can be used to specify files containing precompiled modules.
   Args.AddAllArgs(CmdArgs, options::OPT_fmodule_file);
 
   // -fmodule-cache-path specifies where our implicitly-built module files
   // should be written.
-  SmallString<128> ModuleCachePath;
+  Path = "";
   if (Arg *A = Args.getLastArg(options::OPT_fmodules_cache_path))
-    ModuleCachePath = A->getValue();
+    Path = A->getValue();
   if (HaveModules) {
     if (C.isForDiagnostics()) {
       // When generating crash reports, we want to emit the modules along with
       // the reproduction sources, so we ignore any provided module path.
-      ModuleCachePath = Output.getFilename();
-      llvm::sys::path::replace_extension(ModuleCachePath, ".cache");
-      llvm::sys::path::append(ModuleCachePath, "modules");
-    } else if (ModuleCachePath.empty()) {
+      Path = Output.getFilename();
+      llvm::sys::path::replace_extension(Path, ".cache");
+      llvm::sys::path::append(Path, "modules");
+    } else if (Path.empty()) {
       // No module path was provided: use the default.
       llvm::sys::path::system_temp_directory(/*erasedOnReboot=*/false,
-                                             ModuleCachePath);
-      llvm::sys::path::append(ModuleCachePath, "org.llvm.clang.");
-      appendUserToPath(ModuleCachePath);
-      llvm::sys::path::append(ModuleCachePath, "ModuleCache");
+                                             Path);
+      llvm::sys::path::append(Path, "org.llvm.clang.");
+      appendUserToPath(Path);
+      llvm::sys::path::append(Path, "ModuleCache");
     }
     const char Arg[] = "-fmodules-cache-path=";
-    ModuleCachePath.insert(ModuleCachePath.begin(), Arg, Arg + strlen(Arg));
-    CmdArgs.push_back(Args.MakeArgString(ModuleCachePath));
+    Path.insert(Path.begin(), Arg, Arg + strlen(Arg));
+    CmdArgs.push_back(Args.MakeArgString(Path));
   }
 
   // When building modules and generating crashdumps, we need to dump a module
   // dependency VFS alongside the output.
   if (HaveModules && C.isForDiagnostics()) {
     SmallString<128> VFSDir(Output.getFilename());
     llvm::sys::path::replace_extension(VFSDir, ".cache");
     // Add the cache directory as a temp so the crash diagnostics pick it up.