Use StringRef in Option library instead of raw pointers (NFC)

[mehdi_amini]

Summary

Try to convert llvm/lib/Option library away from raw
const char * pointers to handle string. Also propagating to
the uses of the API in clang itself.

[zturner]

I can review this in more detail later. But my hope is that we can move to StringRef and improve code at the same time, so that it's more than just churn. One thing I've found in doing this with LLDB is that it's easy to introduce bugs, because once you get StringRef and you decide to port some C-style string manipulation, the resulting StringRef code is more elegant, but since it is re-written it has the potential to introduce new bugs. As a result, I've found smaller CLs to be much more workable.

Did you find that it was impossible to do this in a smaller CL? For example, the first change I see is changing this:

const char *addTempFile(const char *Name)

to this:

llvm::StringRef addTempFile(llvm::StringRef Name)

If instead you started from a blank slate and changed it to this:

llvm::StringRef addTempFile(const char *Name)

You would get a lot of immediate compilation failures, which you could fix up and (theoretically) end up with a CL much smaller than what you have here. Did you try that and find it impractical for some reason?

[mehdi_amini]

In D25257#561642, @zturner wrote:

but since it is re-written it has the potential to introduce new bugs.

Yes, I spent 2 days debugging this one because of subtleties...

As a result, I've found smaller CLs to be much more workable.

This is one patch in a ~40 patches queue, I let you imagine how much smaller it is from the main diff :)

Did you find that it was impossible to do this in a smaller CL?

It is possible, I have to go through intermediate stages where I have a lot of conversion through .data() for instance. So when you have something working it is quite hard to go back.
Also the story of this patch is that I have a queue of patches to update all the LLVM APIs, and now I update the other subprojects (clang, lld, lldb) before committing these individual patches. So the question is "how do I proceed?". What depth do I propagate the change?

For example, the first change I see is changing this:

const char *addTempFile(const char *Name)

to this:

llvm::StringRef addTempFile(llvm::StringRef Name)

If instead you started from a blank slate and changed it to this:

llvm::StringRef addTempFile(const char *Name)

You would get a lot of immediate compilation failures, which you could fix up and (theoretically) end up with a CL much smaller than what you have here. Did you try that and find it impractical for some reason?

I started from a patch ready in LLVM that convert the Option library. So the issue is as I update the clang codebase to adapt for the change, there a some minor API like the one you're mentioning that come up. I can "stash" my current patch and deal with this API, before coming back to the current patch. However that's not practical: I have to rebuild the full codebase every time and it takes *long* (I only have a laptop for that, not a large workstation).

As mentioned above, if you think it is better, I can go through intermediate stages where I just add a bunch of .data() conversion. But this intermediate stage will not look pretty.

[rnk]

clang/include/clang/Driver/Job.h

76

I don't like declaring a template in the header without defining it in the header. Let's just keep it const char *. It calls llvm::sys::ExecuteAndWait, which takes const char * because it calls execv/posix_spawn, which take C strings. The only other use is to implement Command::Print, which can suffer the const char *'s.

clang/lib/Driver/Compilation.cpp

101–102

You can change CleanupFile to take StringRef, and not do the dangerous data call.

clang/lib/Driver/Driver.cpp

97

Hang on, nullptr is different from an empty string in the response file parsing logic. We have to be careful not to affect that.

llvm/include/llvm/Support/CommandLine.h

1806–1811

I don't think this is the same for MarkEOLs = true. Command lines can totally contain empty string arguments that do not mark response file line endings.

Probably the right way to do this is to have a second optional output vector that has the indices of all the response file line endings.

[zturner]

I guess my comment applies everywhere there is a call to .data(). Suppose you shelve this CL, then go change some of the places where you are using .data() in this CL to accept StringRef arguments, then rebase this CL on top of those. Since those functions have been left alone in this CL, I would guess that many of them are independent of the changes in this CL and could be converted to StringRef first (and in much smaller CLs), then when you come back to this one you won't have to use .data() so much.

As mentioned in the first comment though, whenever .data() is necessary, I would tend to favor .str().c_str() (the fact that it is inefficient compared to .data() could serve as more incentive to go fix the other places first so that you don't have to do either one)

clang/lib/Driver/Compilation.cpp

101–102

In general, I prefer it->str().c_str() over data() almost everywhere. Yes it's slower, but we shouldn't be making any assumptions about the underlying StringRef. And anyway, in this particular case we're dealing with the filesystem. An extra alloc isn't goign to hurt.

clang/lib/Driver/Driver.cpp

618

Can you change Command::printArg to take a StringRef? If it's too hard to change it outright, you could add an overload.

796

Can setResponseFile take a StringRef?

1168

Can BindArchAction take a StringRef?

1310

Can LookupTypeForExtension take a StringRef?

1350

Same as above.

2314

Same here.

[zturner]

stuff.patch6 KBDownload

Attached is a sample patch that converts some of the simpler functions to accepting StringRef. This should get rid of some of the data() calls. There's more functions you can do this too as well, I didn't want to go too deep though. I think you should do this for as many functions as possible, then rebase on top of that and remove all those data calls. We can look at the rest after. In general though I'm against using data() anywhere if at all possible.

clang/lib/Driver/Tools.cpp

137

In this case, there's no reason for data at all. You should change the for loop to use a range based for over ArgStr.

[mehdi_amini]

clang/lib/Driver/Driver.cpp

97

Good to know, during a recent discussion about StringRef we were wondering about examples where we'd like to differentiate between empty and null.

It seems we don't have any test that rely on this different right now, and I don't know about the "response file" (what are they, how to use them), I so don't feel I can come up easily with a test without guidance.

llvm/include/llvm/Support/CommandLine.h

1806–1811

This is the same underlying issue as above right?
We "could" actually look through .data() to differentiate empty string from nullptr, but I'm not fan of this...

[zturner]

I just had an idea. Why not add an llvm::StringPool to the Compilation. This would pretty much solve all ownership problems.

[mehdi_amini]

I'm not aware of any ownership issue here, so I don’t know what you’re referring to?

[zturner]

In D25257#565088, @mehdi_amini wrote:

I'm not aware of any ownership issue here, so I don’t know what you’re referring to?

The ownership problem I'm referring to is that if you return a str.str().c_str(), the resulting c_str() will die immediately, whereas the caller might need the pointer to remain alive. A StringSaver would solve that, so that you could return Saver.save(str).data() anywhere you would normally want to return str.data()

[mehdi_amini]

The ownership problem I'm referring to is that if you return a str.str().c_str(), the resulting c_str() will die immediately, whereas the caller might need the pointer to remain alive. A StringSaver would solve that, so that you could return Saver.save(str).data() anywhere you would normally want to return str.data()

I see: you're referring to an ownership issue that don't exist in the code but that you want to introduce by forcing allocations where we don't need to.

[mehdi_amini]

Update more APIs to take StringRef to remove calls to .data()

[mehdi_amini]

clang/lib/Driver/Driver.cpp

97

@rnk ping

[klimek]

Drive-by comment regarding the process of creating changes like this:
In our somewhat larger codebase we've found that the best way to create this type of CL is by writing a clang tool:

• the clang tool can be reviewed on its own, and behavior can be bikeshed on the tests
• it's easy to re-run a clang tool on a subset of the interfaces to produce any size CL you want
• if you can make it (or convert it into) a clang-tidy check with a fixit, we prevent regressions

That said, if others are fine reviewing this change I'm fine with it; this is mainly an idea for the future :)

[mehdi_amini]

Abandon after D25639 went dead.

[rnk]

hm, this comment has been sitting unsubmitted for a while.

clang/lib/Driver/Driver.cpp

97

We mark EOLs in the response file mostly so that we can be compatible with MSVC, which has arguments that consume everything following them. Given this response file, the compilation command should get all the -D flags, and the link should get 3 -debug flags:

$ cat foo.rsp
-DFOO -link -debug
-DBAR -link -debug
-DBAZ -link -debug

$ clang-cl t.cpp @foo.rsp -###
...
"clang-cl" "-cc1" ... "-D" "FOO" "-D" "BAR" "-D" "BAZ"  ...
"link.exe" "-out:t.exe" "-nologo" "-debug" "-debug" "-debug" ...

So, we need a way to distinguish between empty strings and EOLs.

I mentioned one way to do this:

Probably the right way to do this is to have a second optional output vector that has the indices of all the response file line endings.

clang-tools-extra/modularize/Modularize.cpp

 // Save the command line for comments.
 std::string CommandLine;
 
 // Helper function for finding the input file in an arguments list.
 static std::string findInputFile(const CommandLineArguments &CLArgs) {
   std::unique_ptr<OptTable> Opts(createDriverOptTable());
   const unsigned IncludedFlagsBitmask = options::CC1Option;
   unsigned MissingArgIndex, MissingArgCount;
-  SmallVector<const char *, 256> Argv;
-  for (CommandLineArguments::const_iterator I = CLArgs.begin(),
-                                            E = CLArgs.end();
-       I != E; ++I)
-    Argv.push_back(I->c_str());
+  SmallVector<StringRef, 256> Argv;
+  for (const auto &Str : CLArgs)
+    Argv.push_back(Str);
   InputArgList Args = Opts->ParseArgs(Argv, MissingArgIndex, MissingArgCount,
                                       IncludedFlagsBitmask);
   std::vector<std::string> Inputs = Args.getAllArgValues(OPT_INPUT);
   return ModularizeUtilities::getCanonicalPath(Inputs.back());
 }
 
 // This arguments adjuster inserts "-include (file)" arguments for header
 // dependencies.  It also inserts a "-w" option and a "-x c++",

clang/include/clang/Basic/Builtins.h

public:
   }
 
   /// Return real buitin ID (i.e. ID it would have furing compilation
   /// for AuxTarget).
   unsigned getAuxBuiltinID(unsigned ID) const { return ID - TSRecords.size(); }
 
   /// Returns true if this is a libc/libm function without the '__builtin_'
   /// prefix.
-  static bool isBuiltinFunc(const char *Name);
+  static bool isBuiltinFunc(llvm::StringRef Name);
 
 private:
   const Info &getRecord(unsigned ID) const;
 
   /// \brief Is this builtin supported according to the given language options?
   bool builtinIsSupported(const Builtin::Info &BuiltinInfo,
                           const LangOptions &LangOpts);
 

clang/include/clang/Driver/Compilation.h

public:
   /// tool chain \p TC (or the default tool chain, if TC is not specified).
   ///
   /// \param BoundArch - The bound architecture name, or 0.
   const llvm::opt::DerivedArgList &getArgsForToolChain(const ToolChain *TC,
                                                        StringRef BoundArch);
 
   /// addTempFile - Add a file to remove on exit, and returns its
   /// argument.
-  const char *addTempFile(const char *Name) {
+  StringRef addTempFile(StringRef Name) {
     TempFiles.push_back(Name);
     return Name;
   }
 
   /// addResultFile - Add a file to remove on failure, and returns its
   /// argument.
-  const char *addResultFile(const char *Name, const JobAction *JA) {
+  StringRef addResultFile(StringRef Name, const JobAction *JA) {
     ResultFiles[JA] = Name;
     return Name;
   }
 
   /// addFailureResultFile - Add a file to remove if we crash, and returns its
   /// argument.
-  const char *addFailureResultFile(const char *Name, const JobAction *JA) {
+  StringRef addFailureResultFile(StringRef Name, const JobAction *JA) {
     FailureResultFiles[JA] = Name;
     return Name;
   }
 
   /// CleanupFile - Delete a given file.
   ///
   /// \param IssueErrors - Report failures as errors.
   /// \return Whether the file was removed successfully.
-  bool CleanupFile(const char *File, bool IssueErrors = false) const;
+  bool CleanupFile(StringRef File, bool IssueErrors = false) const;
 
   /// CleanupFileList - Remove the files in the given list.
   ///
   /// \param IssueErrors - Report failures as errors.
   /// \return Whether all files were removed successfully.
   bool CleanupFileList(const llvm::opt::ArgStringList &Files,
                        bool IssueErrors = false) const;
 

clang/include/clang/Driver/Driver.h

public:
 
   /// BuildCompilation - Construct a compilation object for a command
   /// line argument vector.
   ///
   /// \return A compilation, or 0 if none was built for the given
   /// argument vector. A null return value does not necessarily
   /// indicate an error condition, the diagnostics should be queried
   /// to determine if an error occurred.
-  Compilation *BuildCompilation(ArrayRef<const char *> Args);
+  Compilation *BuildCompilation(ArrayRef<StringRef> Args);
 
   /// @name Driver Steps
   /// @{
 
   /// ParseDriverMode - Look for and handle the driver mode option in Args.
-  void ParseDriverMode(StringRef ProgramName, ArrayRef<const char *> Args);
+  void ParseDriverMode(StringRef ProgramName, ArrayRef<StringRef> Args);
 
   /// ParseArgStrings - Parse the given list of strings into an
   /// ArgList.
-  llvm::opt::InputArgList ParseArgStrings(ArrayRef<const char *> Args);
+  llvm::opt::InputArgList ParseArgStrings(ArrayRef<StringRef> Args);
 
   /// BuildInputs - Construct the list of inputs and their types from 
   /// the given arguments.
   ///
   /// \param TC - The default host tool chain.
   /// \param Args - The input arguments.
   /// \param Inputs - The list to store the resulting compilation 
   /// inputs onto.
public:
   /// \param C - The compilation.
   /// \param JA - The action of interest.
   /// \param BaseInput - The original input file that this action was
   /// triggered by.
   /// \param BoundArch - The bound architecture. 
   /// \param AtTopLevel - Whether this is a "top-level" action.
   /// \param MultipleArchs - Whether multiple -arch options were supplied.
   /// \param NormalizedTriple - The normalized triple of the relevant target.
-  const char *GetNamedOutputPath(Compilation &C, const JobAction &JA,
-                                 const char *BaseInput, StringRef BoundArch,
-                                 bool AtTopLevel, bool MultipleArchs,
-                                 StringRef NormalizedTriple) const;
+  StringRef GetNamedOutputPath(Compilation &C, const JobAction &JA,
+                               StringRef BaseInput, StringRef BoundArch,
 
   /// GetTemporaryPath - Return the pathname of a temporary file to use 
   /// as part of compilation; the file will have the given prefix and suffix.
   ///
   /// GCC goes to extra lengths here to be a bit more robust.
   std::string GetTemporaryPath(StringRef Prefix, StringRef Suffix) const;
 
   /// Return the pathname of the pch file in clang-cl mode.

clang/include/clang/Driver/Job.h

 class Command {
   /// Source - The action which caused the creation of this job.
   const Action &Source;
 
   /// Tool - The tool which caused the creation of this job.
   const Tool &Creator;
 
   /// The executable to run.
-  const char *Executable;
+  StringRef Executable;
 
   /// The list of program arguments (not including the implicit first
   /// argument, which will be the executable).
   llvm::opt::ArgStringList Arguments;
 
   /// The list of program arguments which are inputs.
   llvm::opt::ArgStringList InputFilenames;
 
   /// Response file name, if this command is set to use one, or nullptr
   /// otherwise
   StringRef ResponseFile;
 
   /// The input file list in case we need to emit a file list instead of a
   /// proper response file
   llvm::opt::ArgStringList InputFileList;
 
   /// String storage if we need to create a new argument to specify a response
   /// file
   std::string ResponseFileFlag;
 
   /// When a response file is needed, we try to put most arguments in an
   /// exclusive file, while others remains as regular command line arguments.
   /// This functions fills a vector with the regular command line arguments,
   /// argv, excluding the ones passed in a response file.
-  void buildArgvForResponseFile(llvm::SmallVectorImpl<const char *> &Out) const;
+  void buildArgvForResponseFile(llvm::SmallVectorImpl<StringRef> &Out) const;
 
   /// Encodes an array of C strings into a single string separated by whitespace.
   /// This function will also put in quotes arguments that have whitespaces and
   /// will escape the regular backslashes (used in Windows paths) and quotes.
   /// The results are the contents of a response file, written into a raw_ostream.
   void writeResponseFile(raw_ostream &OS) const;
 
 public:
-  Command(const Action &Source, const Tool &Creator, const char *Executable,
+  Command(const Action &Source, const Tool &Creator, StringRef Executable,
           const llvm::opt::ArgStringList &Arguments,
           ArrayRef<InputInfo> Inputs);
   // FIXME: This really shouldn't be copyable, but is currently copied in some
   // error handling in Driver::generateCompilationDiagnostics.
   Command(const Command &) = default;
   virtual ~Command() {}
 
   virtual void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote,
public:
   void setResponseFile(StringRef FileName);
 
   /// Set an input file list, necessary if we need to use a response file but
   /// the tool being called only supports input files lists.
   void setInputFileList(llvm::opt::ArgStringList List) {
     InputFileList = std::move(List);
   }
 
-  const char *getExecutable() const { return Executable; }
+  StringRef getExecutable() const { return Executable; }
 
   const llvm::opt::ArgStringList &getArguments() const { return Arguments; }
 
   /// Print a command argument, and optionally quote it.
   static void printArg(llvm::raw_ostream &OS, StringRef Arg, bool Quote);
 };
 
 /// Like Command, but with a fallback which is executed in case
 /// the primary command crashes.
 class FallbackCommand : public Command {
 public:
   FallbackCommand(const Action &Source_, const Tool &Creator_,
-                  const char *Executable_, const ArgStringList &Arguments_,
+                  StringRef Executable_, const ArgStringList &Arguments_,
                   ArrayRef<InputInfo> Inputs,
                   std::unique_ptr<Command> Fallback_);
 
   void Print(llvm::raw_ostream &OS, const char *Terminator, bool Quote,
              CrashReportInfo *CrashInfo = nullptr) const override;
 
   int Execute(const StringRef **Redirects, std::string *ErrMsg,
               bool *ExecutionFailed) const override;

clang/include/clang/Driver/ToolChain.h

public:
   ///
   /// This can be overridden when a particular ToolChain needs to use
   /// a compiler other than Clang.
   virtual Tool *SelectTool(const JobAction &JA) const;
 
   // Helper methods
 
   std::string GetFilePath(const char *Name) const;
-  std::string GetProgramPath(const char *Name) const;
+  std::string GetProgramPath(StringRef Name) const;
 
   /// Returns the linker path, respecting the -fuse-ld= argument to determine
   /// the linker suffix or name.
   std::string GetLinkerPath() const;
 
   /// \brief Dispatch to the specific toolchain for verbose printing.
   ///
   /// This is used when handling the verbose option to print detailed,
public:
   virtual CXXStdlibType GetDefaultCXXStdlibType() const {
     return ToolChain::CST_Libstdcxx;
   }
 
   virtual std::string getCompilerRT(const llvm::opt::ArgList &Args,
                                     StringRef Component,
                                     bool Shared = false) const;
 
-  const char *getCompilerRTArgString(const llvm::opt::ArgList &Args,
-                                     StringRef Component,
-                                     bool Shared = false) const;
+  StringRef getCompilerRTArgString(const llvm::opt::ArgList &Args,
   /// needsProfileRT - returns true if instrumentation profile is on.
   static bool needsProfileRT(const llvm::opt::ArgList &Args);
 
   /// IsUnwindTablesDefault - Does this tool chain use -funwind-tables
   /// by default.
   virtual bool IsUnwindTablesDefault() const;
 
   /// \brief Test whether this toolchain defaults to PIC.

clang/include/clang/Driver/Types.h

#undef TYPE
   bool isObjC(ID Id);
 
   /// lookupTypeForExtension - Lookup the type to use for the file
   /// extension \p Ext.
   ID lookupTypeForExtension(llvm::StringRef Ext);
 
   /// lookupTypeForTypSpecifier - Lookup the type to use for a user
   /// specified type name.
-  ID lookupTypeForTypeSpecifier(const char *Name);
+  ID lookupTypeForTypeSpecifier(llvm::StringRef Name);
 
   /// getCompilationPhases - Get the list of compilation phases ('Phases') to be
   /// done for type 'Id'.
   void getCompilationPhases(
     ID Id,
     llvm::SmallVectorImpl<phases::ID> &Phases);
 
   /// lookupCXXTypeForCType - Lookup CXX input type that corresponds to given

clang/include/clang/Driver/Util.h

 namespace clang {
 class DiagnosticsEngine;
 
 namespace driver {
   class Action;
   class JobAction;
 
   /// ArgStringMap - Type used to map a JobAction to its result file.
-  typedef llvm::DenseMap<const JobAction*, const char*> ArgStringMap;
+  typedef llvm::DenseMap<const JobAction *, StringRef> ArgStringMap;
 
   /// ActionList - Type used for lists of actions.
   typedef SmallVector<Action*, 3> ActionList;
 
 } // end namespace driver
 } // end namespace clang
 
 #endif

clang/include/clang/Frontend/CompilerInvocation.h

public:
   /// \param ArgBegin - The first element in the argument vector.
   /// \param ArgEnd - The last element in the argument vector.
   /// \param Diags - The diagnostic engine to use for errors.
   static bool CreateFromArgs(CompilerInvocation &Res,
                              const char* const *ArgBegin,
                              const char* const *ArgEnd,
                              DiagnosticsEngine &Diags);
 
+  /// \brief Create a compiler invocation from a list of input options.
+  /// \returns true on success.
+  ///
+  /// \param [out] Res - The resulting invocation.
+  /// \param ArgBegin - The first element in the argument vector.
+  /// \param ArgEnd - The last element in the argument vector.
+  /// \param Diags - The diagnostic engine to use for errors.
+  static bool CreateFromArgs(CompilerInvocation &Res, const StringRef *ArgBegin,
+                             const StringRef *ArgEnd, DiagnosticsEngine &Diags);
+
   /// \brief Get the directory where the compiler headers
   /// reside, relative to the compiler binary (found by the passed in
   /// arguments).
   ///
   /// \param Argv0 - The program path (from argv[0]), for finding the builtin
   /// compiler path.
   /// \param MainAddr - The address of main (or some other function in the main
   /// executable), for finding the builtin compiler path.
-  static std::string GetResourcesPath(const char *Argv0, void *MainAddr);
+  static std::string GetResourcesPath(StringRef Argv0, void *MainAddr);
 
   /// \brief Set language defaults for the given input language and
   /// language standard in the given LangOptions object.
   ///
   /// \param Opts - The LangOptions object to set up.
   /// \param IK - The input language.
   /// \param T - The target triple.
   /// \param PPOpts - The PreprocessorOptions affected.

clang/include/clang/Tooling/Tooling.h

public:
   /// \brief Run the clang invocation.
   ///
   /// \returns True if there were no errors during execution.
   bool run();
 
  private:
   void addFileMappingsTo(SourceManager &SourceManager);
 
-  bool runInvocation(const char *BinaryName,
+  bool runInvocation(StringRef BinaryName,
                      clang::driver::Compilation *Compilation,
                      clang::CompilerInvocation *Invocation,
                      std::shared_ptr<PCHContainerOperations> PCHContainerOps);
 
   std::vector<std::string> CommandLine;
   ToolAction *Action;
   bool OwnsAction;
   FileManager *Files;

clang/lib/Basic/Builtins.cpp

 void Builtin::Context::InitializeTarget(const TargetInfo &Target,
                                         const TargetInfo *AuxTarget) {
   assert(TSRecords.empty() && "Already initialized target?");
   TSRecords = Target.getTargetBuiltins();
   if (AuxTarget)
     AuxTSRecords = AuxTarget->getTargetBuiltins();
 }
 
-bool Builtin::Context::isBuiltinFunc(const char *Name) {
-  StringRef FuncName(Name);
+bool Builtin::Context::isBuiltinFunc(llvm::StringRef FuncName) {
   for (unsigned i = Builtin::NotBuiltin + 1; i != Builtin::FirstTSBuiltin; ++i)
     if (FuncName.equals(BuiltinInfo[i].Name))
       return strchr(BuiltinInfo[i].Attributes, 'f') != nullptr;
 
   return false;
 }
 
 bool Builtin::Context::builtinIsSupported(const Builtin::Info &BuiltinInfo,

clang/lib/Driver/Compilation.cpp

if (!Entry) {
     Entry = TC->TranslateArgs(*TranslatedArgs, BoundArch);
     if (!Entry)
       Entry = TranslatedArgs;
   }
 
   return *Entry;
 }
 
-bool Compilation::CleanupFile(const char *File, bool IssueErrors) const {
+bool Compilation::CleanupFile(StringRef File, bool IssueErrors) const {
   // FIXME: Why are we trying to remove files that we have not created? For
   // example we should only try to remove a temporary assembly file if
   // "clang -cc1" succeed in writing it. Was this a workaround for when
   // clang was writing directly to a .s file and sometimes leaving it behind
   // during a failure?
 
   // FIXME: If this is necessary, we can still try to split
   // llvm::sys::fs::remove into a removeFile and a removeDir and avoid the
if (std::error_code EC = llvm::sys::fs::remove(File)) {
     return false;
   }
   return true;
 }
 
 bool Compilation::CleanupFileList(const ArgStringList &Files,
                                   bool IssueErrors) const {
   bool Success = true;
-  for (ArgStringList::const_iterator
-         it = Files.begin(), ie = Files.end(); it != ie; ++it)
-    Success &= CleanupFile(*it, IssueErrors);
+  for (auto File : Files)
+    Success &= CleanupFile(File, IssueErrors);
   return Success;
 }
 
 bool Compilation::CleanupFileMap(const ArgStringMap &Files,
                                  const JobAction *JA,
                                  bool IssueErrors) const {
   bool Success = true;
-  for (ArgStringMap::const_iterator
-         it = Files.begin(), ie = Files.end(); it != ie; ++it) {
-
+  for (auto &Arg : Files) {
     // If specified, only delete the files associated with the JobAction.
     // Otherwise, delete all files in the map.
-    if (JA && it->first != JA)
+    if (JA && Arg.first != JA)
       continue;
-    Success &= CleanupFile(it->second, IssueErrors);
+    Success &= CleanupFile(Arg.second, IssueErrors);
   }
   return Success;
 }
 
 int Compilation::ExecuteCommand(const Command &C,
                                 const Command *&FailingCommand) const {
   if ((getDriver().CCPrintOptions ||
        getArgs().hasArg(options::OPT_v)) && !getDriver().CCGenDiagnostics) {

clang/lib/Driver/Driver.cpp

 }
 
 Driver::~Driver() {
   delete Opts;
 
   llvm::DeleteContainerSeconds(ToolChains);
 }
 
-void Driver::ParseDriverMode(StringRef ProgramName,
-                             ArrayRef<const char *> Args) {
+void Driver::ParseDriverMode(StringRef ProgramName, ArrayRef<StringRef> Args) {
   auto Default = ToolChain::getTargetAndModeFromProgramName(ProgramName);
   StringRef DefaultMode(Default.second);
   setDriverModeFromOption(DefaultMode);
 
-  for (const char *ArgPtr : Args) {
+  for (StringRef Arg : Args) {
     // Ingore nullptrs, they are response file's EOL markers
-    if (ArgPtr == nullptr)
+    if (Arg.empty())
       continue;
-    const StringRef Arg = ArgPtr;
     setDriverModeFromOption(Arg);
   }
 }
 
 void Driver::setDriverModeFromOption(StringRef Opt) {
   const std::string OptName =
       getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
   if (!Opt.startswith(OptName))
     return;
   StringRef Value = Opt.drop_front(OptName.size());
 
   const unsigned M = llvm::StringSwitch<unsigned>(Value)
                          .Case("gcc", GCCMode)
                          .Case("g++", GXXMode)
                          .Case("cpp", CPPMode)
                          .Case("cl", CLMode)
                          .Default(~0U);
 
   if (M != ~0U)
     Mode = static_cast<DriverMode>(M);
   else
     Diag(diag::err_drv_unsupported_option_argument) << OptName << Value;
 }
 
-InputArgList Driver::ParseArgStrings(ArrayRef<const char *> ArgStrings) {
+InputArgList Driver::ParseArgStrings(ArrayRef<StringRef> ArgStrings) {
   llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
 
   unsigned IncludedFlagsBitmask;
   unsigned ExcludedFlagsBitmask;
   std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
       getIncludeExcludeOptionFlagMasks();
 
   unsigned MissingArgIndex, MissingArgCount;
if (FinalPhaseArg)
     *FinalPhaseArg = PhaseArg;
 
   return FinalPhase;
 }
 
 static Arg *MakeInputArg(DerivedArgList &Args, OptTable *Opts,
                          StringRef Value) {
   Arg *A = new Arg(Opts->getOption(options::OPT_INPUT), Value,
-                   Args.getBaseArgs().MakeIndex(Value), Value.data());
+                   Args.getBaseArgs().MakeIndex(Value), Value);
   Args.AddSynthesizedArg(A);
   A->claim();
   return A;
 }
 
 DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {
   DerivedArgList *DAL = new DerivedArgList(Args);
 
void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
 
   //
   // TODO: Add support for other offloading programming models here.
   //
 
   return;
 }
 
-Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
+Compilation *Driver::BuildCompilation(ArrayRef<StringRef> ArgList) {
   llvm::PrettyStackTraceString CrashInfo("Compilation construction");
 
   // FIXME: Handle environment options which affect driver behavior, somewhere
   // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS.
 
   if (Optional<std::string> CompilerPathValue =
           llvm::sys::Process::GetEnv("COMPILER_PATH")) {
     StringRef CompilerPath = *CompilerPathValue;

 static void printArgList(raw_ostream &OS, const llvm::opt::ArgList &Args) {
   llvm::opt::ArgStringList ASL;
   for (const auto *A : Args)
     A->render(Args, ASL);
 
   for (auto I = ASL.begin(), E = ASL.end(); I != E; ++I) {
     if (I != ASL.begin())
       OS << ' ';
     Command::printArg(OS, *I, true);
   }
   OS << '\n';
 }
 
 // When clang crashes, produce diagnostic information including the fully
 // preprocessed source file(s).  Request that the developer attach the
 // diagnostic information to a bug report.
 void Driver::generateCompilationDiagnostics(Compilation &C,
void Driver::generateCompilationDiagnostics(Compilation &C,
 
   for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
     bool IgnoreInput = false;
 
     // Ignore input from stdin or any inputs that cannot be preprocessed.
     // Check type first as not all linker inputs have a value.
     if (types::getPreprocessedType(it->first) == types::TY_INVALID) {
       IgnoreInput = true;
-    } else if (!strcmp(it->second->getValue(), "-")) {
+    } else if (it->second->getValue() == "-") {
       Diag(clang::diag::note_drv_command_failed_diag_msg)
           << "Error generating preprocessed source(s) - "
              "ignoring input from stdin.";
       IgnoreInput = true;
     }
 
     if (IgnoreInput) {
       it = Inputs.erase(it);
void Driver::generateCompilationDiagnostics(Compilation &C,
   }
 
   Diag(clang::diag::note_drv_command_failed_diag_msg)
       << "\n********************\n\n"
          "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n"
          "Preprocessed source(s) and associated run script(s) are located at:";
 
   SmallString<128> VFS;
-  for (const char *TempFile : TempFiles) {
+  for (StringRef TempFile : TempFiles) {
     Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile;
-    if (StringRef(TempFile).endswith(".cache")) {
+    if (TempFile.endswith(".cache")) {
       // In some cases (modules) we'll dump extra data to help with reproducing
       // the crash into a directory next to the output.
       VFS = llvm::sys::path::filename(TempFile);
       llvm::sys::path::append(VFS, "vfs", "vfs.yaml");
     }
   }
 
   // Assume associated files are based off of the first temporary file.
void Driver::setUpResponseFiles(Compilation &C, Command &Cmd) {
   // Since commandLineFitsWithinSystemLimits() may underestimate system's capacity
   // if the tool does not support response files, there is a chance/ that things
   // will just work without a response file, so we silently just skip it.
   if (Cmd.getCreator().getResponseFilesSupport() == Tool::RF_None ||
       llvm::sys::commandLineFitsWithinSystemLimits(Cmd.getExecutable(), Cmd.getArguments()))
     return;
 
   std::string TmpName = GetTemporaryPath("response", "txt");
-  Cmd.setResponseFile(
-      C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())));
+  Cmd.setResponseFile(C.addTempFile(C.getArgs().MakeArgString(TmpName)));
 }
 
 int Driver::ExecuteCompilation(
     Compilation &C,
     SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) {
   // Just print if -### was present.
   if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
     C.getJobs().Print(llvm::errs(), "\n", true);

 void Driver::BuildUniversalActions(Compilation &C, const ToolChain &TC,
                                    const InputList &BAInputs) const {
   DerivedArgList &Args = C.getArgs();
   ActionList &Actions = C.getActions();
   llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
   // Collect the list of architectures. Duplicates are allowed, but should only
   // be handled once (in the order seen).
   llvm::StringSet<> ArchNames;
-  SmallVector<const char *, 4> Archs;
+  SmallVector<StringRef, 4> Archs;
   for (Arg *A : Args) {
     if (A->getOption().matches(options::OPT_arch)) {
       // Validate the option here; we don't save the type here because its
       // particular spelling may participate in other driver choices.
       llvm::Triple::ArchType Arch =
           tools::darwin::getArchTypeForMachOArchName(A->getValue());
       if (Arch == llvm::Triple::UnknownArch) {
         Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
for (Action* Act : SingleActions) {
     // -save-temps. Compatibility wins for now.
 
     if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
       Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
           << types::getTypeName(Act->getType());
 
     ActionList Inputs;
     for (unsigned i = 0, e = Archs.size(); i != e; ++i)
       Inputs.push_back(C.MakeAction<BindArchAction>(Act, Archs[i]));
 
     // Lipo if necessary, we do it this way because we need to set the arch flag
     // so that -Xarch_ gets overwritten.
     if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
       Actions.append(Inputs.begin(), Inputs.end());
     else
       Actions.push_back(C.MakeAction<LipoJobAction>(Inputs, Act->getType()));
 
if (ShowNote)
       Diag(clang::diag::note_drv_t_option_is_global);
 
     // No driver mode exposes -x and /TC or /TP; we don't support mixing them.
     assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed");
   }
 
   for (Arg *A : Args) {
     if (A->getOption().getKind() == Option::InputClass) {
-      const char *Value = A->getValue();
+      StringRef Value = A->getValue();
       types::ID Ty = types::TY_INVALID;
 
       // Infer the input type if necessary.
       if (InputType == types::TY_Nothing) {
         // If there was an explicit arg for this, claim it.
         if (InputTypeArg)
           InputTypeArg->claim();
 
         // stdin must be handled specially.
-        if (memcmp(Value, "-", 2) == 0) {
+        if (Value == "-") {
           // If running with -E, treat as a C input (this changes the builtin
           // macros, for example). This may be overridden by -ObjC below.
           //
           // Otherwise emit an error but still use a valid type to avoid
           // spurious errors (e.g., no inputs).
           if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP())
             Diag(IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
                             : clang::diag::err_drv_unknown_stdin_type);
           Ty = types::TY_C;
         } else {
           // Otherwise lookup by extension.
           // Fallback is C if invoked as C preprocessor or Object otherwise.
           // We use a host hook here because Darwin at least has its own
           // idea of what .s is.
-          if (const char *Ext = strrchr(Value, '.'))
-            Ty = TC.LookupTypeForExtension(Ext + 1);
+          auto ExtIdx = Value.rfind('.');
+          if (ExtIdx != StringRef::npos)
+            Ty = TC.LookupTypeForExtension(Value.drop_front(ExtIdx + 1));
 
           if (Ty == types::TY_INVALID) {
             if (CCCIsCPP())
               Ty = types::TY_C;
             else
               Ty = types::TY_Object;
           }
 
if (A->getOption().getKind() == Option::InputClass) {
           else if (Args.hasArg(options::OPT_ObjCXX))
             Ty = types::TY_ObjCXX;
         }
       } else {
         assert(InputTypeArg && "InputType set w/o InputTypeArg");
         if (!InputTypeArg->getOption().matches(options::OPT_x)) {
           // If emulating cl.exe, make sure that /TC and /TP don't affect input
           // object files.
-          const char *Ext = strrchr(Value, '.');
-          if (Ext && TC.LookupTypeForExtension(Ext + 1) == types::TY_Object)
+          auto ExtIdx = Value.find('.');
+          if (ExtIdx != StringRef::npos) {
+            StringRef Ext = Value.drop_front(ExtIdx + 1);
+            if (TC.LookupTypeForExtension(Ext) == types::TY_Object)
               Ty = types::TY_Object;
           }
+        }
         if (Ty == types::TY_INVALID) {
           Ty = InputType;
           InputTypeArg->claim();
         }
       }
 
       if (DiagnoseInputExistence(*this, Args, Value, Ty))
         Inputs.push_back(std::make_pair(Ty, A));
if (YcArg && YcArg->getValue()[0] == '\0') {
     Args.eraseArg(options::OPT__SLASH_Yc);
     YcArg = nullptr;
   }
   if (YuArg && YuArg->getValue()[0] == '\0') {
     Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YuArg->getSpelling();
     Args.eraseArg(options::OPT__SLASH_Yu);
     YuArg = nullptr;
   }
-  if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
+  if (YcArg && YuArg && YcArg->getValue() != YuArg->getValue()) {
     Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl);
     Args.eraseArg(options::OPT__SLASH_Yc);
     Args.eraseArg(options::OPT__SLASH_Yu);
     YcArg = YuArg = nullptr;
   }
   if (YcArg || YuArg) {
     StringRef Val = YcArg ? YcArg->getValue() : YuArg->getValue();
     bool FoundMatchingInclude = false;
void Driver::BuildJobs(Compilation &C) const {
   std::map<std::pair<const Action *, std::string>, InputInfo> CachedResults;
   for (Action *A : C.getActions()) {
     // If we are linking an image for multiple archs then the linker wants
     // -arch_multiple and -final_output <final image name>. Unfortunately, this
     // doesn't fit in cleanly because we have to pass this information down.
     //
     // FIXME: This is a hack; find a cleaner way to integrate this into the
     // process.
-    const char *LinkingOutput = nullptr;
+    StringRef LinkingOutput;
     if (isa<LipoJobAction>(A)) {
       if (FinalOutput)
         LinkingOutput = FinalOutput->getValue();
       else
         LinkingOutput = getDefaultImageName();
     }
 
     BuildJobsForAction(C, A, &C.getDefaultToolChain(),
                        /*BoundArch*/ StringRef(),
                        /*AtTopLevel*/ true,
                        /*MultipleArchs*/ ArchNames.size() > 1,
                        /*LinkingOutput*/ LinkingOutput, CachedResults,
                        /*BuildForOffloadDevice*/ false);
   }
 
   // If the user passed -Qunused-arguments or there were errors, don't warn
   // about any unused arguments.
   if (Diags.hasErrorOccurred() ||
       C.getArgs().hasArg(options::OPT_Qunused_arguments))
     return;
InputInfo Driver::BuildJobsForActionNoCache(
   }
 
   if (const InputAction *IA = dyn_cast<InputAction>(A)) {
     // FIXME: It would be nice to not claim this here; maybe the old scheme of
     // just using Args was better?
     const Arg &Input = IA->getInputArg();
     Input.claim();
     if (Input.getOption().matches(options::OPT_INPUT)) {
-      const char *Name = Input.getValue();
+      StringRef Name = Input.getValue();
       return InputInfo(A, Name, /* BaseInput = */ Name);
     }
     return InputInfo(A, &Input, /* BaseInput = */ "");
   }
 
   if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
     const ToolChain *TC;
     StringRef ArchName = BAA->getArchName();
for (const Action *Input : *Inputs) {
     bool SubJobAtTopLevel =
         AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A));
     InputInfos.push_back(BuildJobsForAction(
         C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, LinkingOutput,
         CachedResults, BuildForOffloadDevice));
   }
 
   // Always use the first input as the base input.
-  const char *BaseInput = InputInfos[0].getBaseInput();
+  StringRef BaseInput = InputInfos[0].getBaseInput();
 
   // ... except dsymutil actions, which use their actual input as the base
   // input.
   if (JA->getType() == types::TY_dSYM)
     BaseInput = InputInfos[0].getFilename();
 
   // Append outputs of offload device jobs to the input list
   if (!OffloadDependencesInputInfo.empty())
const char *Driver::getDefaultImageName() const {
   llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
   return Target.isOSWindows() ? "a.exe" : "a.out";
 }
 
 /// \brief Create output filename based on ArgValue, which could either be a
 /// full filename, filename without extension, or a directory. If ArgValue
 /// does not provide a filename, then use BaseName, and use the extension
 /// suitable for FileType.
-static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue,
-                                        StringRef BaseName,
-                                        types::ID FileType) {
+static StringRef MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue,
+                                      StringRef BaseName, types::ID FileType) {
   SmallString<128> Filename = ArgValue;
 
   if (ArgValue.empty()) {
     // If the argument is empty, output to BaseName in the current dir.
     Filename = BaseName;
   } else if (llvm::sys::path::is_separator(Filename.back())) {
     // If the argument is a directory, output to BaseName in that dir.
     llvm::sys::path::append(Filename, BaseName);
if (!llvm::sys::path::has_extension(ArgValue)) {
     }
 
     llvm::sys::path::replace_extension(Filename, Extension);
   }
 
   return Args.MakeArgString(Filename.c_str());
 }
 
-const char *Driver::GetNamedOutputPath(Compilation &C, const JobAction &JA,
-                                       const char *BaseInput,
-                                       StringRef BoundArch, bool AtTopLevel,
-                                       bool MultipleArchs,
-                                       StringRef NormalizedTriple) const {
+StringRef Driver::GetNamedOutputPath(Compilation &C, const JobAction &JA,
+                                     StringRef BaseInput, StringRef BoundArch,
+                                     bool AtTopLevel, bool MultipleArchs,
   llvm::PrettyStackTraceString CrashInfo("Computing output path");
   // Output to a user requested destination?
   if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) {
     if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
       return C.addResultFile(FinalOutput->getValue(), &JA);
   }
 
   // For /P, preprocess to file named after BaseInput.
StringRef Driver::GetNamedOutputPath(Compilation &C, const JobAction &JA,
 
   // Dsymutil actions should use the full path.
   if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
     BaseName = BasePath;
   else
     BaseName = llvm::sys::path::filename(BasePath);
 
   // Determine what the derived output name should be.
-  const char *NamedOutput;
+  StringRef NamedOutput;
 
   if ((JA.getType() == types::TY_Object || JA.getType() == types::TY_LTO_BC) &&
       C.getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
     // The /Fo or /o flag decides the object filename.
     StringRef Val =
         C.getArgs()
             .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)
             ->getValue();

clang/lib/Driver/InputInfo.h

class InputInfo {
   enum Class {
     Nothing,
     Filename,
     InputArg,
     Pipe
   };
 
   union {
-    const char *Filename;
+    StringRef Filename = StringRef();
     const llvm::opt::Arg *InputArg;
   } Data;
   Class Kind;
   const Action* Act;
   types::ID Type;
-  const char *BaseInput;
+  StringRef BaseInput;
 
   static types::ID GetActionType(const Action *A) {
     return A != nullptr ? A->getType() : types::TY_Nothing;
   }
 
 public:
-  InputInfo() : InputInfo(nullptr, nullptr) {}
-  InputInfo(const Action *A, const char *_BaseInput)
+  InputInfo() : InputInfo(nullptr, StringRef()) {}
+  InputInfo(const Action *A, StringRef _BaseInput)
       : Kind(Nothing), Act(A), Type(GetActionType(A)), BaseInput(_BaseInput) {}
 
-  InputInfo(types::ID _Type, const char *_Filename, const char *_BaseInput)
+  InputInfo(types::ID _Type, StringRef FName, StringRef _BaseInput)
       : Kind(Filename), Act(nullptr), Type(_Type), BaseInput(_BaseInput) {
-    Data.Filename = _Filename;
+    Data.Filename = FName;
   }
-  InputInfo(const Action *A, const char *_Filename, const char *_BaseInput)
+  InputInfo(const Action *A, StringRef FName, StringRef _BaseInput)
       : Kind(Filename), Act(A), Type(GetActionType(A)), BaseInput(_BaseInput) {
-    Data.Filename = _Filename;
+    Data.Filename = FName;
   }
 
   InputInfo(types::ID _Type, const llvm::opt::Arg *_InputArg,
-            const char *_BaseInput)
+            StringRef _BaseInput)
       : Kind(InputArg), Act(nullptr), Type(_Type), BaseInput(_BaseInput) {
     Data.InputArg = _InputArg;
   }
   InputInfo(const Action *A, const llvm::opt::Arg *_InputArg,
-            const char *_BaseInput)
+            StringRef _BaseInput)
       : Kind(InputArg), Act(A), Type(GetActionType(A)), BaseInput(_BaseInput) {
     Data.InputArg = _InputArg;
   }
 
   bool isNothing() const { return Kind == Nothing; }
   bool isFilename() const { return Kind == Filename; }
   bool isInputArg() const { return Kind == InputArg; }
   types::ID getType() const { return Type; }
-  const char *getBaseInput() const { return BaseInput; }
+  StringRef getBaseInput() const { return BaseInput; }
   /// The action for which this InputInfo was created.  May be null.
   const Action *getAction() const { return Act; }
   void setAction(const Action *A) { Act = A; }
 
-  const char *getFilename() const {
+  StringRef getFilename() const {
     assert(isFilename() && "Invalid accessor.");
     return Data.Filename;
   }
   const llvm::opt::Arg &getInputArg() const {
     assert(isInputArg() && "Invalid accessor.");
     return *Data.InputArg;
   }
 
   /// getAsString - Return a string name for this input, for
   /// debugging.
   std::string getAsString() const {
     if (isFilename())
-      return std::string("\"") + getFilename() + '"';
+      return std::string("\"") + getFilename().str() + '"';
     else if (isInputArg())
       return "(input arg)";
     else
       return "(nothing)";
   }
 };
 
 } // end namespace driver
 } // end namespace clang
 
 #endif

clang/lib/Driver/Job.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <cassert>
 using namespace clang::driver;
 using llvm::raw_ostream;
 using llvm::StringRef;
 using llvm::ArrayRef;
 
 Command::Command(const Action &Source, const Tool &Creator,
-                 const char *Executable, const ArgStringList &Arguments,
+                 StringRef Executable, const ArgStringList &Arguments,
                  ArrayRef<InputInfo> Inputs)
     : Source(Source), Creator(Creator), Executable(Executable),
       Arguments(Arguments) {
   for (const auto &II : Inputs)
     if (II.isFilename())
       InputFilenames.push_back(II.getFilename());
 }
 
-static int skipArgs(const char *Flag, bool HaveCrashVFS) {
+static int skipArgs(StringRef Flag, bool HaveCrashVFS) {
   // These flags are all of the form -Flag <Arg> and are treated as two
   // arguments.  Therefore, we need to skip the flag and the next argument.
   bool Res = llvm::StringSwitch<bool>(Flag)
     .Cases("-MF", "-MT", "-MQ", "-serialize-diagnostic-file", true)
     .Cases("-o", "-coverage-file", "-dependency-file", true)
     .Cases("-fdebug-compilation-dir", "-idirafter", true)
     .Cases("-include", "-include-pch", "-internal-isystem", true)
     .Cases("-internal-externc-isystem", "-iprefix", "-iwithprefix", true)
Res = llvm::StringSwitch<bool>(Flag)
     .Case("-MMD", true)
     .Default(false);
 
   // Match found.
   if (Res)
     return 1;
 
   // These flags are treated as a single argument (e.g., -F<Dir>).
-  StringRef FlagRef(Flag);
   if ((!HaveCrashVFS &&
-       (FlagRef.startswith("-F") || FlagRef.startswith("-I"))) ||
-      FlagRef.startswith("-fmodules-cache-path="))
+       (Flag.startswith("-F") || Flag.startswith("-I"))) ||
+      Flag.startswith("-fmodules-cache-path="))
     return 1;
 
   return 0;
 }
 
 void Command::printArg(raw_ostream &OS, StringRef Arg, bool Quote) {
   const bool Escape = Arg.find_first_of("\"\\$") != StringRef::npos;
 
for (const char c : Arg) {
     OS << c;
   }
   OS << '"';
 }
 
 void Command::writeResponseFile(raw_ostream &OS) const {
   // In a file list, we only write the set of inputs to the response file
   if (Creator.getResponseFilesSupport() == Tool::RF_FileList) {
-    for (const char *Arg : InputFileList) {
+    for (auto Arg : InputFileList) {
       OS << Arg << '\n';
     }
     return;
   }
 
   // In regular response files, we send all arguments to the response file.
   // Wrapping all arguments in double quotes ensures that both Unix tools and
   // Windows tools understand the response file.
-  for (const char *Arg : Arguments) {
+  for (auto ArgStr : Arguments) {
     OS << '"';
-
-    for (; *Arg != '\0'; Arg++) {
-      if (*Arg == '\"' || *Arg == '\\') {
+    for (auto C : ArgStr) {
+      if (C == '\"' || C == '\\') {
         OS << '\\';
       }
-      OS << *Arg;
+      OS << C;
     }
 
     OS << "\" ";
   }
 }
 
 void Command::buildArgvForResponseFile(
-    llvm::SmallVectorImpl<const char *> &Out) const {
+    llvm::SmallVectorImpl<StringRef> &Out) const {
   // When not a file list, all arguments are sent to the response file.
   // This leaves us to set the argv to a single parameter, requesting the tool
   // to read the response file.
   if (Creator.getResponseFilesSupport() != Tool::RF_FileList) {
     Out.push_back(Executable);
-    Out.push_back(ResponseFileFlag.c_str());
+    Out.push_back(ResponseFileFlag);
     return;
   }
 
   llvm::StringSet<> Inputs;
-  for (const char *InputName : InputFileList)
+  for (auto InputName : InputFileList)
     Inputs.insert(InputName);
   Out.push_back(Executable);
   // In a file list, build args vector ignoring parameters that will go in the
   // response file (elements of the InputFileList vector)
   bool FirstInput = true;
-  for (const char *Arg : Arguments) {
+  for (auto Arg : Arguments) {
     if (Inputs.count(Arg) == 0) {
       Out.push_back(Arg);
     } else if (FirstInput) {
       FirstInput = false;
       Out.push_back(Creator.getResponseFileFlag());
-      Out.push_back(ResponseFile.data());
+      Out.push_back(ResponseFile);
     }
   }
 }
 
 void Command::Print(raw_ostream &OS, const char *Terminator, bool Quote,
                     CrashReportInfo *CrashInfo) const {
   // Always quote the exe.
   OS << ' ';
   printArg(OS, Executable, /*Quote=*/true);
 
-  llvm::ArrayRef<const char *> Args = Arguments;
-  llvm::SmallVector<const char *, 128> ArgsRespFile;
+  llvm::ArrayRef<StringRef> Args = Arguments;
+  llvm::SmallVector<StringRef, 128> ArgsRespFile;
   if (!ResponseFile.empty()) {
     buildArgvForResponseFile(ArgsRespFile);
-    Args = ArrayRef<const char *>(ArgsRespFile).slice(1); // no executable name
+    Args = ArrayRef<StringRef>(ArgsRespFile).slice(1); // no executable name
   }
 
   bool HaveCrashVFS = CrashInfo && !CrashInfo->VFSPath.empty();
   for (size_t i = 0, e = Args.size(); i < e; ++i) {
-    const char *const Arg = Args[i];
+    StringRef Arg = Args[i];
 
     if (CrashInfo) {
       if (int Skip = skipArgs(Arg, HaveCrashVFS)) {
         i += Skip - 1;
         continue;
       }
       auto Found = std::find_if(InputFilenames.begin(), InputFilenames.end(),
                                 [&Arg](StringRef IF) { return IF == Arg; });

 void Command::setResponseFile(StringRef FileName) {
   ResponseFile = FileName;
   ResponseFileFlag = Creator.getResponseFileFlag();
   ResponseFileFlag += FileName;
 }
 
 int Command::Execute(const StringRef **Redirects, std::string *ErrMsg,
                      bool *ExecutionFailed) const {
+
   SmallVector<const char*, 128> Argv;
 
   if (ResponseFile.empty()) {
-    Argv.push_back(Executable);
-    Argv.append(Arguments.begin(), Arguments.end());
+    // Go through std::string to ensure null termination
+    SmallVector<std::string, 128> ArgvStr;
+    ArgvStr.push_back(Executable);
+    for (auto &Arg : Arguments)
+      ArgvStr.push_back(Arg);
+
+    Argv.reserve(ArgvStr.size());
+    for (auto &Str : ArgvStr)
+      Argv.push_back(Str.c_str());
     Argv.push_back(nullptr);
 
     return llvm::sys::ExecuteAndWait(Executable, Argv.data(), /*env*/ nullptr,
                                      Redirects, /*secondsToWait*/ 0,
                                      /*memoryLimit*/ 0, ErrMsg,
                                      ExecutionFailed);
   }
 
   // We need to put arguments in a response file (command is too large)
   // Open stream to store the response file contents
   std::string RespContents;
   llvm::raw_string_ostream SS(RespContents);
 
   // Write file contents and build the Argv vector
   writeResponseFile(SS);
-  buildArgvForResponseFile(Argv);
-  Argv.push_back(nullptr);
+  SmallVector<StringRef, 128> ArgvStrRef;
+  buildArgvForResponseFile(ArgvStrRef);
   SS.flush();
 
+  // Go through std::string to ensure null termination
+  SmallVector<std::string, 128> ArgvStr;
+  for (auto &Arg : ArgvStrRef)
+    ArgvStr.push_back(Arg);
+  Argv.reserve(ArgvStr.size());
+  for (auto &Str : ArgvStr)
+    Argv.push_back(Str.c_str());
+  Argv.push_back(nullptr);
+
   // Save the response file in the appropriate encoding
   if (std::error_code EC = writeFileWithEncoding(
           ResponseFile, RespContents, Creator.getResponseFileEncoding())) {
     if (ErrMsg)
       *ErrMsg = EC.message();
     if (ExecutionFailed)
       *ExecutionFailed = true;
     return -1;
   }
 
   return llvm::sys::ExecuteAndWait(Executable, Argv.data(), /*env*/ nullptr,
                                    Redirects, /*secondsToWait*/ 0,
                                    /*memoryLimit*/ 0, ErrMsg, ExecutionFailed);
 }
 
 FallbackCommand::FallbackCommand(const Action &Source_, const Tool &Creator_,
-                                 const char *Executable_,
+                                 StringRef Executable_,
                                  const ArgStringList &Arguments_,
                                  ArrayRef<InputInfo> Inputs,
                                  std::unique_ptr<Command> Fallback_)
     : Command(Source_, Creator_, Executable_, Arguments_, Inputs),
       Fallback(std::move(Fallback_)) {}
 
 void FallbackCommand::Print(raw_ostream &OS, const char *Terminator,
                             bool Quote, CrashReportInfo *CrashInfo) const {

clang/lib/Driver/SanitizerArgs.cpp

assert((A->getOption().matches(options::OPT_fsanitize_EQ) ||
           A->getOption().matches(options::OPT_fno_sanitize_EQ) ||
           A->getOption().matches(options::OPT_fsanitize_recover_EQ) ||
           A->getOption().matches(options::OPT_fno_sanitize_recover_EQ) ||
           A->getOption().matches(options::OPT_fsanitize_trap_EQ) ||
           A->getOption().matches(options::OPT_fno_sanitize_trap_EQ)) &&
          "Invalid argument in parseArgValues!");
   SanitizerMask Kinds = 0;
   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
-    const char *Value = A->getValue(i);
+    StringRef Value = A->getValue(i);
     SanitizerMask Kind;
     // Special case: don't accept -fsanitize=all.
-    if (A->getOption().matches(options::OPT_fsanitize_EQ) &&
-        0 == strcmp("all", Value))
+    if (A->getOption().matches(options::OPT_fsanitize_EQ) && Value == "all")
       Kind = 0;
     // Similarly, don't accept -fsanitize=efficiency-all.
     else if (A->getOption().matches(options::OPT_fsanitize_EQ) &&
-        0 == strcmp("efficiency-all", Value))
+             Value == "efficiency-all")
       Kind = 0;
     else
       Kind = parseSanitizerValue(Value, /*AllowGroups=*/true);
 
     if (Kind)
       Kinds |= Kind;
     else if (DiagnoseErrors)
       D.Diag(clang::diag::err_drv_unsupported_option_argument)
           << A->getOption().getName() << Value;
   }
   return Kinds;
 }
 
 int parseCoverageFeatures(const Driver &D, const llvm::opt::Arg *A) {
   assert(A->getOption().matches(options::OPT_fsanitize_coverage) ||
          A->getOption().matches(options::OPT_fno_sanitize_coverage));
   int Features = 0;
   for (int i = 0, n = A->getNumValues(); i != n; ++i) {
-    const char *Value = A->getValue(i);
+    StringRef Value = A->getValue(i);
     int F = llvm::StringSwitch<int>(Value)
         .Case("func", CoverageFunc)
         .Case("bb", CoverageBB)
         .Case("edge", CoverageEdge)
         .Case("indirect-calls", CoverageIndirCall)
         .Case("trace-bb", CoverageTraceBB)
         .Case("trace-cmp", CoverageTraceCmp)
         .Case("trace-div", CoverageTraceDiv)

clang/lib/Driver/ToolChain.cpp

std::string ToolChain::getCompilerRT(const ArgList &Args, StringRef Component,
   SmallString<128> Path(getDriver().ResourceDir);
   StringRef OSLibName = Triple.isOSFreeBSD() ? "freebsd" : getOS();
   llvm::sys::path::append(Path, "lib", OSLibName);
   llvm::sys::path::append(Path, Prefix + Twine("clang_rt.") + Component + "-" +
                                     Arch + Env + Suffix);
   return Path.str();
 }
 
-const char *ToolChain::getCompilerRTArgString(const llvm::opt::ArgList &Args,
-                                              StringRef Component,
-                                              bool Shared) const {
+StringRef ToolChain::getCompilerRTArgString(const llvm::opt::ArgList &Args,
   return Args.MakeArgString(getCompilerRT(Args, Component, Shared));
 }
 
 bool ToolChain::needsProfileRT(const ArgList &Args) {
   if (Args.hasFlag(options::OPT_fprofile_arcs, options::OPT_fno_profile_arcs,
                    false) ||
       Args.hasArg(options::OPT_fprofile_generate) ||
       Args.hasArg(options::OPT_fprofile_generate_EQ) ||
if (AC == Action::AssembleJobClass && useIntegratedAs())
     return getClangAs();
   return getTool(AC);
 }
 
 std::string ToolChain::GetFilePath(const char *Name) const {
   return D.GetFilePath(Name, *this);
 }
 
-std::string ToolChain::GetProgramPath(const char *Name) const {
+std::string ToolChain::GetProgramPath(StringRef Name) const {
   return D.GetProgramPath(Name, *this);
 }
 
 std::string ToolChain::GetLinkerPath() const {
   if (Arg *A = Args.getLastArg(options::OPT_fuse_ld_EQ)) {
     StringRef UseLinker = A->getValue();
 
     if (llvm::sys::path::is_absolute(UseLinker)) {

clang/lib/Driver/ToolChains.cpp

else
     llvm_unreachable("Unable to infer Darwin variant");
 
   // Set the tool chain target information.
   unsigned Major, Minor, Micro;
   bool HadExtra;
   if (Platform == MacOS) {
     assert((!iOSVersion && !TvOSVersion && !WatchOSVersion) &&
            "Unknown target platform!");
-    if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor, Micro,
-                                   HadExtra) ||
+    if (!Driver::GetReleaseVersion(OSXVersion->getValue(), Major, Minor,
+                                   Micro, HadExtra) ||
         HadExtra || Major != 10 || Minor >= 100 || Micro >= 100)
       getDriver().Diag(diag::err_drv_invalid_version_number)
           << OSXVersion->getAsString(Args);
   } else if (Platform == IPhoneOS) {
     assert(iOSVersion && "Unknown target platform!");
-    if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor, Micro,
-                                   HadExtra) ||
+    if (!Driver::GetReleaseVersion(iOSVersion->getValue(), Major, Minor,
+                                   Micro, HadExtra) ||
         HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
       getDriver().Diag(diag::err_drv_invalid_version_number)
           << iOSVersion->getAsString(Args);
   } else if (Platform == TvOS) {
     if (!Driver::GetReleaseVersion(TvOSVersion->getValue(), Major, Minor,
-                                   Micro, HadExtra) || HadExtra ||
-        Major >= 100 || Minor >= 100 || Micro >= 100)
+                                   Micro, HadExtra) ||
+        HadExtra || Major >= 100 || Minor >= 100 || Micro >= 100)
       getDriver().Diag(diag::err_drv_invalid_version_number)
           << TvOSVersion->getAsString(Args);
   } else if (Platform == WatchOS) {
-    if (!Driver::GetReleaseVersion(WatchOSVersion->getValue(), Major, Minor,
-                                   Micro, HadExtra) || HadExtra ||
-        Major >= 10 || Minor >= 100 || Micro >= 100)
+    if (!Driver::GetReleaseVersion(WatchOSVersion->getValue(), Major,
+                                   Minor, Micro, HadExtra) ||
+        HadExtra || Major >= 10 || Minor >= 100 || Micro >= 100)
       getDriver().Diag(diag::err_drv_invalid_version_number)
           << WatchOSVersion->getAsString(Args);
   } else
     llvm_unreachable("unknown kind of Darwin platform");
 
   // Recognize iOS targets with an x86 architecture as the iOS simulator.
   if (iOSVersion && (getTriple().getArch() == llvm::Triple::x86 ||
                      getTriple().getArch() == llvm::Triple::x86_64))
if (A->getOption().matches(options::OPT_Xarch__)) {
       A = XarchArg.release();
       DAL->AddSynthesizedArg(A);
 
       // Linker input arguments require custom handling. The problem is that we
       // have already constructed the phase actions, so we can not treat them as
       // "input arguments".
       if (A->getOption().hasFlag(options::LinkerInput)) {
         // Convert the argument into individual Zlinker_input_args.
-        for (const char *Value : A->getValues()) {
+        for (StringRef Value : A->getValues()) {
           DAL->AddSeparateArg(
               OriginalArg, Opts.getOption(options::OPT_Zlinker_input), Value);
         }
         continue;
       }
     }
 
     // Sob. These is strictly gcc compatible for the time being. Apple
if (Args.hasArg(options::OPT_bundle)) {
         }
       }
     }
   }
 
   if (!isTargetIPhoneOS() && Args.hasArg(options::OPT_shared_libgcc) &&
       !isTargetWatchOS() &&
       isMacosxVersionLT(10, 5)) {
-    const char *Str = Args.MakeArgString(GetFilePath("crt3.o"));
+    StringRef Str = Args.MakeArgString(GetFilePath("crt3.o"));
     CmdArgs.push_back(Str);
   }
 }
 
 bool Darwin::SupportsObjCGC() const { return isTargetMacOS(); }
 
 void Darwin::CheckObjCARC() const {
   if (isTargetIOSBased() || isTargetWatchOSBased() ||

 void HexagonToolChain::getHexagonLibraryPaths(const ArgList &Args,
       ToolChain::path_list &LibPaths) const {
   const Driver &D = getDriver();
 
   //----------------------------------------------------------------------------
   // -L Args
   //----------------------------------------------------------------------------
   for (Arg *A : Args.filtered(options::OPT_L))
-    for (const char *Value : A->getValues())
+    for (StringRef Value : A->getValues())
       LibPaths.push_back(Value);
 
   //----------------------------------------------------------------------------
   // Other standard paths
   //----------------------------------------------------------------------------
   std::vector<std::string> RootDirs;
   std::copy(D.PrefixDirs.begin(), D.PrefixDirs.end(),
             std::back_inserter(RootDirs));

clang/lib/Driver/Tools.h

 
 SmallString<128> getCompilerRT(const ToolChain &TC,
                                const llvm::opt::ArgList &Args,
                                StringRef Component, bool Shared = false);
 
 /// \brief Clang compiler tool.
 class LLVM_LIBRARY_VISIBILITY Clang : public Tool {
 public:
-  static const char *getBaseInputName(const llvm::opt::ArgList &Args,
-                                      const InputInfo &Input);
-  static const char *getBaseInputStem(const llvm::opt::ArgList &Args,
-                                      const InputInfoList &Inputs);
-  static const char *getDependencyFileName(const llvm::opt::ArgList &Args,
-                                           const InputInfoList &Inputs);
+  static StringRef getBaseInputName(const llvm::opt::ArgList &Args,
+  static StringRef getBaseInputStem(const llvm::opt::ArgList &Args,
+  static StringRef getDependencyFileName(const llvm::opt::ArgList &Args,
 
 private:
   void AddPreprocessingOptions(Compilation &C, const JobAction &JA,
                                const Driver &D, const llvm::opt::ArgList &Args,
                                llvm::opt::ArgStringList &CmdArgs,
                                const InputInfo &Output,
                                const InputInfoList &Inputs) const;
 

clang/lib/Driver/Tools.cpp

if (const Arg *A =
             Args.getLastArg(options::OPT_dynamic, options::OPT_mdynamic_no_pic))
       D.Diag(diag::err_drv_argument_not_allowed_with) << A->getAsString(Args)
                                                       << "-static";
 }
 
 // Add backslashes to escape spaces and other backslashes.
 // This is used for the space-separated argument list specified with
 // the -dwarf-debug-flags option.
-static void EscapeSpacesAndBackslashes(const char *Arg,
+static void EscapeSpacesAndBackslashes(StringRef ArgStr,
                                        SmallVectorImpl<char> &Res) {
-  for (; *Arg; ++Arg) {
-    switch (*Arg) {
+  for (auto Arg : ArgStr) {
+    switch (Arg) {
     default:
       break;
     case ' ':
     case '\\':
       Res.push_back('\\');
       break;
     }
-    Res.push_back(*Arg);
+    Res.push_back(Arg);
   }
 }
 
 // Quote target names for inclusion in GNU Make dependency files.
 // Only the characters '$', '#', ' ', '\t' are quoted.
 static void QuoteTarget(StringRef Target, SmallVectorImpl<char> &Res) {
   for (unsigned i = 0, e = Target.size(); i != e; ++i) {
     switch (Target[i]) {
void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA,
   Args.AddLastArg(CmdArgs, options::OPT_C);
   Args.AddLastArg(CmdArgs, options::OPT_CC);
 
   // Handle dependency file generation.
   if ((A = Args.getLastArg(options::OPT_M, options::OPT_MM)) ||
       (A = Args.getLastArg(options::OPT_MD)) ||
       (A = Args.getLastArg(options::OPT_MMD))) {
     // Determine the output location.
-    const char *DepFile;
+    StringRef DepFile;
     if (Arg *MF = Args.getLastArg(options::OPT_MF)) {
       DepFile = MF->getValue();
       C.addFailureResultFile(DepFile, &JA);
     } else if (Output.getType() == types::TY_Dependencies) {
       DepFile = Output.getFilename();
     } else if (A->getOption().matches(options::OPT_M) ||
                A->getOption().matches(options::OPT_MM)) {
       DepFile = "-";
     } else {
       DepFile = getDependencyFileName(Args, Inputs);
       C.addFailureResultFile(DepFile, &JA);
     }
     CmdArgs.push_back("-dependency-file");
     CmdArgs.push_back(DepFile);
 
     // Add a default target if one wasn't specified.
     if (!Args.hasArg(options::OPT_MT) && !Args.hasArg(options::OPT_MQ)) {
-      const char *DepTarget;
+      StringRef DepTarget;
 
       // If user provided -o, that is the dependency target, except
       // when we are only generating a dependency file.
       Arg *OutputOpt = Args.getLastArg(options::OPT_o);
       if (OutputOpt && Output.getType() != types::TY_Dependencies) {
         DepTarget = OutputOpt->getValue();
       } else {
         // Otherwise derive from the base input.
int YcIndex = -1, YuIndex = -1;
     const Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
     const Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
     for (const Arg *A : Args.filtered(options::OPT_clang_i_Group)) {
       // Walk the whole i_Group and skip non "-include" flags so that the index
       // here matches the index in the next loop below.
       ++AI;
       if (!A->getOption().matches(options::OPT_include))
         continue;
-      if (YcArg && strcmp(A->getValue(), YcArg->getValue()) == 0)
+      if (YcArg && A->getValue() == YcArg->getValue())
         YcIndex = AI;
-      if (YuArg && strcmp(A->getValue(), YuArg->getValue()) == 0)
+      if (YuArg && A->getValue() == YuArg->getValue())
         YuIndex = AI;
     }
   }
   if (isa<PrecompileJobAction>(JA) && YcIndex != -1) {
     Driver::InputList Inputs;
     D.BuildInputs(getToolChain(), C.getArgs(), Inputs);
     assert(Inputs.size() == 1 && "Need one input when building pch");
     CmdArgs.push_back(Args.MakeArgString(Twine("-find-pch-source=") +
void Clang::AddPreprocessingOptions(Compilation &C, const JobAction &JA,
 
   // -I- is a deprecated GCC feature, reject it.
   if (Arg *A = Args.getLastArg(options::OPT_I_))
     D.Diag(diag::err_drv_I_dash_not_supported) << A->getAsString(Args);
 
   // If we have a --sysroot, and don't have an explicit -isysroot flag, add an
   // -isysroot to the CC1 invocation.
   StringRef sysroot = C.getSysRoot();
-  if (sysroot != "") {
+  if (!sysroot.empty()) {
     if (!Args.hasArg(options::OPT_isysroot)) {
       CmdArgs.push_back("-isysroot");
       CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
     }
   }
 
   // Parse additional include paths from environment variables.
   // FIXME: We should probably sink the logic for handling these from the
if (KernelOrKext || Args.hasArg(options::OPT_mno_movt))
     Features.push_back("+no-movt");
 }
 
 void Clang::AddARMTargetArgs(const llvm::Triple &Triple, const ArgList &Args,
                              ArgStringList &CmdArgs, bool KernelOrKext) const {
   // Select the ABI to use.
   // FIXME: Support -meabi.
   // FIXME: Parts of this are duplicated in the backend, unify this somehow.
-  const char *ABIName = nullptr;
+  StringRef ABIName;
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ)) {
     ABIName = A->getValue();
   } else if (Triple.isOSBinFormatMachO()) {
     if (useAAPCSForMachO(Triple)) {
       ABIName = "aapcs";
     } else if (Triple.isWatchABI()) {
       ABIName = "aapcs16";
     } else {
if (!Args.hasFlag(options::OPT_mred_zone, options::OPT_mno_red_zone, true) ||
       Args.hasArg(options::OPT_mkernel) ||
       Args.hasArg(options::OPT_fapple_kext))
     CmdArgs.push_back("-disable-red-zone");
 
   if (!Args.hasFlag(options::OPT_mimplicit_float,
                     options::OPT_mno_implicit_float, true))
     CmdArgs.push_back("-no-implicit-float");
 
-  const char *ABIName = nullptr;
+  StringRef ABIName;
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
     ABIName = A->getValue();
   else if (Triple.isOSDarwin())
     ABIName = "darwinpcs";
   else
     ABIName = "aapcs";
 
   CmdArgs.push_back("-target-abi");
ppc::FloatABI ppc::getPPCFloatABI(const Driver &D, const ArgList &Args) {
   }
 
   return ABI;
 }
 
 void Clang::AddPPCTargetArgs(const ArgList &Args,
                              ArgStringList &CmdArgs) const {
   // Select the ABI to use.
-  const char *ABIName = nullptr;
+  StringRef ABIName;
   if (getToolChain().getTriple().isOSLinux())
     switch (getToolChain().getArch()) {
     case llvm::Triple::ppc64: {
       // When targeting a processor that supports QPX, or if QPX is
       // specifically enabled, default to using the ABI that supports QPX (so
       // long as it is not specifically disabled).
       bool HasQPX = false;
       if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ))
if (getToolChain().getTriple().isOSLinux())
     default:
       break;
     }
 
   if (Arg *A = Args.getLastArg(options::OPT_mabi_EQ))
     // The ppc64 linux abis are all "altivec" abis by default. Accept and ignore
     // the option if given as we don't have backend support for any targets
     // that don't use the altivec abi.
-    if (StringRef(A->getValue()) != "altivec")
+    if (A->getValue() != "altivec")
       ABIName = A->getValue();
 
   ppc::FloatABI FloatABI =
       ppc::getPPCFloatABI(getToolChain().getDriver(), Args);
 
   if (FloatABI == ppc::FloatABI::Soft) {
     // Floating point operations and argument passing are soft.
     CmdArgs.push_back("-msoft-float");
     CmdArgs.push_back("-mfloat-abi");
     CmdArgs.push_back("soft");
   } else {
     // Floating point operations and argument passing are hard.
     assert(FloatABI == ppc::FloatABI::Hard && "Invalid float abi!");
     CmdArgs.push_back("-mfloat-abi");
     CmdArgs.push_back("hard");
   }
 
-  if (ABIName) {
+  if (!ABIName.empty()) {
     CmdArgs.push_back("-target-abi");
     CmdArgs.push_back(ABIName);
   }
 }
 
 bool ppc::hasPPCAbiArg(const ArgList &Args, const char *Value) {
   Arg *A = Args.getLastArg(options::OPT_mabi_EQ);
   return A && (A->getValue() == StringRef(Value));
 }
 
 /// Get the (LLVM) name of the R600 gpu we are targeting.
 static std::string getR600TargetGPU(const ArgList &Args) {
   if (Arg *A = Args.getLastArg(options::OPT_mcpu_EQ)) {
-    const char *GPUName = A->getValue();
-    return llvm::StringSwitch<const char *>(GPUName)
+    StringRef GPUName = A->getValue();
+    return llvm::StringSwitch<StringRef>(GPUName)
         .Cases("rv630", "rv635", "r600")
         .Cases("rv610", "rv620", "rs780", "rs880")
         .Case("rv740", "rv770")
         .Case("palm", "cedar")
         .Cases("sumo", "sumo2", "sumo")
         .Case("hemlock", "cypress")
         .Case("aruba", "cayman")
         .Default(GPUName);

 }
 
 void Clang::AddSystemZTargetArgs(const ArgList &Args,
                                  ArgStringList &CmdArgs) const {
   if (Args.hasFlag(options::OPT_mbackchain, options::OPT_mno_backchain, false))
     CmdArgs.push_back("-mbackchain");
 }
 
-static const char *getSystemZTargetCPU(const ArgList &Args) {
+static StringRef getSystemZTargetCPU(const ArgList &Args) {
   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ))
     return A->getValue();
   return "z10";
 }
 
 static void getSystemZTargetFeatures(const ArgList &Args,
                                      std::vector<StringRef> &Features) {
   // -m(no-)htm overrides use of the transactional-execution facility.
   if (Arg *A = Args.getLastArg(options::OPT_mhtm, options::OPT_mno_htm)) {
     if (A->getOption().matches(options::OPT_mhtm))
       Features.push_back("+transactional-execution");
     else
       Features.push_back("-transactional-execution");
   }
   // -m(no-)vx overrides use of the vector facility.
   if (Arg *A = Args.getLastArg(options::OPT_mvx, options::OPT_mno_vx)) {
     if (A->getOption().matches(options::OPT_mvx))
       Features.push_back("+vector");
     else
       Features.push_back("-vector");
   }
 }
 
-static const char *getX86TargetCPU(const ArgList &Args,
-                                   const llvm::Triple &Triple) {
+static StringRef getX86TargetCPU(const ArgList &Args,
   if (const Arg *A = Args.getLastArg(options::OPT_march_EQ)) {
     if (StringRef(A->getValue()) != "native") {
       if (Triple.isOSDarwin() && Triple.getArchName() == "x86_64h")
         return "core-avx2";
 
       return A->getValue();
     }
 
if (const Arg *A = Args.getLastArg(options::OPT__SLASH_arch)) {
     if (CPU)
       return CPU;
   }
 
   // Select the default CPU if none was given (or detection failed).
 
   if (Triple.getArch() != llvm::Triple::x86_64 &&
       Triple.getArch() != llvm::Triple::x86)
-    return nullptr; // This routine is only handling x86 targets.
+    return StringRef(); // This routine is only handling x86 targets.
 
   bool Is64Bit = Triple.getArch() == llvm::Triple::x86_64;
 
   // FIXME: Need target hooks.
   if (Triple.isOSDarwin()) {
     if (Triple.getArchName() == "x86_64h")
       return "core-avx2";
     return Is64Bit ? "core2" : "yonah";
static void CollectArgsForIntegratedAssembler(Compilation &C,
   // arg after parsing the '-I' arg.
   bool TakeNextArg = false;
 
   // When using an integrated assembler, translate -Wa, and -Xassembler
   // options.
   bool CompressDebugSections = false;
 
   bool UseRelaxRelocations = ENABLE_X86_RELAX_RELOCATIONS;
-  const char *MipsTargetFeature = nullptr;
+  StringRef MipsTargetFeature;
   for (const Arg *A :
        Args.filtered(options::OPT_Wa_COMMA, options::OPT_Xassembler)) {
     A->claim();
 
     for (StringRef Value : A->getValues()) {
       if (TakeNextArg) {
         CmdArgs.push_back(Value.data());
         TakeNextArg = false;
for (StringRef Value : A->getValues()) {
                                 .Case("-mips32r5", "+mips32r5")
                                 .Case("-mips32r6", "+mips32r6")
                                 .Case("-mips64", "+mips64")
                                 .Case("-mips64r2", "+mips64r2")
                                 .Case("-mips64r3", "+mips64r3")
                                 .Case("-mips64r5", "+mips64r5")
                                 .Case("-mips64r6", "+mips64r6")
                                 .Default(nullptr);
-        if (MipsTargetFeature)
+        if (!MipsTargetFeature.empty())
           continue;
       }
 
       if (Value == "-force_cpusubtype_ALL") {
         // Do nothing, this is the default and we don't support anything else.
       } else if (Value == "-L") {
         CmdArgs.push_back("-msave-temp-labels");
       } else if (Value == "--fatal-warnings") {
static void CollectArgsForIntegratedAssembler(Compilation &C,
   if (CompressDebugSections) {
     if (llvm::zlib::isAvailable())
       CmdArgs.push_back("-compress-debug-sections");
     else
       D.Diag(diag::warn_debug_compression_unavailable);
   }
   if (UseRelaxRelocations)
     CmdArgs.push_back("--mrelax-relocations");
-  if (MipsTargetFeature != nullptr) {
+  if (!MipsTargetFeature.empty()) {
     CmdArgs.push_back("-target-feature");
     CmdArgs.push_back(MipsTargetFeature);
   }
 }
 
 // This adds the static libclang_rt.builtins-arch.a directly to the command line
 // FIXME: Make sure we can also emit shared objects if they're requested
 // and available, check for possible errors, etc.

 static void addDebugCompDirArg(const ArgList &Args, ArgStringList &CmdArgs) {
   SmallString<128> cwd;
   if (!llvm::sys::fs::current_path(cwd)) {
     CmdArgs.push_back("-fdebug-compilation-dir");
     CmdArgs.push_back(Args.MakeArgString(cwd));
   }
 }
 
-static const char *SplitDebugName(const ArgList &Args, const InputInfo &Input) {
+static StringRef SplitDebugName(const ArgList &Args, const InputInfo &Input) {
   Arg *FinalOutput = Args.getLastArg(options::OPT_o);
   if (FinalOutput && Args.hasArg(options::OPT_c)) {
     SmallString<128> T(FinalOutput->getValue());
     llvm::sys::path::replace_extension(T, "dwo");
     return Args.MakeArgString(T);
   } else {
     // Use the compilation dir.
     SmallString<128> T(
         Args.getLastArgValue(options::OPT_fdebug_compilation_dir));
     SmallString<128> F(llvm::sys::path::stem(Input.getBaseInput()));
     llvm::sys::path::replace_extension(F, "dwo");
     T += F;
     return Args.MakeArgString(F);
   }
 }
 
 static void SplitDebugInfo(const ToolChain &TC, Compilation &C, const Tool &T,
                            const JobAction &JA, const ArgList &Args,
-                           const InputInfo &Output, const char *OutFile) {
+                           const InputInfo &Output, StringRef OutFile) {
   ArgStringList ExtractArgs;
   ExtractArgs.push_back("--extract-dwo");
 
   ArgStringList StripArgs;
   StripArgs.push_back("--strip-dwo");
 
   // Grabbing the output of the earlier compile step.
   StripArgs.push_back(Output.getFilename());
   ExtractArgs.push_back(Output.getFilename());
   ExtractArgs.push_back(OutFile);
 
-  const char *Exec = Args.MakeArgString(TC.GetProgramPath("objcopy"));
+  StringRef Exec = Args.MakeArgString(TC.GetProgramPath("objcopy"));
   InputInfo II(types::TY_Object, Output.getFilename(), Output.getFilename());
 
   // First extract the dwo sections.
   C.addCommand(llvm::make_unique<Command>(JA, T, Exec, ExtractArgs, II));
 
   // Then remove them from the original .o file.
   C.addCommand(llvm::make_unique<Command>(JA, T, Exec, StripArgs, II));
 }
#endif
   // analysis.
   if (getToolChain().UseDwarfDebugFlags()) {
     ArgStringList OriginalArgs;
     for (const auto &Arg : Args)
       Arg->render(Args, OriginalArgs);
 
     SmallString<256> Flags;
     Flags += Exec;
-    for (const char *OriginalArg : OriginalArgs) {
+    for (StringRef OriginalArg : OriginalArgs) {
       SmallString<128> EscapedArg;
       EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
       Flags += " ";
       Flags += EscapedArg;
     }
     CmdArgs.push_back("-dwarf-debug-flags");
     CmdArgs.push_back(Args.MakeArgString(Flags));
   }
 
   // Add the split debug info name to the command lines here so we
   // can propagate it to the backend.
   bool SplitDwarf = SplitDwarfArg && getToolChain().getTriple().isOSLinux() &&
                     (isa<AssembleJobAction>(JA) || isa<CompileJobAction>(JA) ||
                      isa<BackendJobAction>(JA));
-  const char *SplitDwarfOut;
+  StringRef SplitDwarfOut;
   if (SplitDwarf) {
     CmdArgs.push_back("-split-dwarf-file");
     SplitDwarfOut = SplitDebugName(Args, Input);
     CmdArgs.push_back(SplitDwarfOut);
   }
 
   // Host-side cuda compilation receives device-side outputs as Inputs[1...].
   // Include them with -fcuda-include-gpubinary.
void ClangAs::ConstructJob(Compilation &C, const JobAction &JA,
   if (getToolChain().UseDwarfDebugFlags()) {
     ArgStringList OriginalArgs;
     for (const auto &Arg : Args)
       Arg->render(Args, OriginalArgs);
 
     SmallString<256> Flags;
     const char *Exec = getToolChain().getDriver().getClangProgramPath();
     Flags += Exec;
-    for (const char *OriginalArg : OriginalArgs) {
+    for (StringRef OriginalArg : OriginalArgs) {
       SmallString<128> EscapedArg;
       EscapeSpacesAndBackslashes(OriginalArg, EscapedArg);
       Flags += " ";
       Flags += EscapedArg;
     }
     CmdArgs.push_back("-dwarf-debug-flags");
     CmdArgs.push_back(Args.MakeArgString(Flags));
   }
void gcc::Common::ConstructJob(Compilation &C, const JobAction &JA,
   const char *GCCName;
   if (!customGCCName.empty())
     GCCName = customGCCName.c_str();
   else if (D.CCCIsCXX()) {
     GCCName = "g++";
   } else
     GCCName = "gcc";
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath(GCCName));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void gcc::Preprocessor::RenderExtraToolArgs(const JobAction &JA,
                                             ArgStringList &CmdArgs) const {
   CmdArgs.push_back("-E");
 }
 
for (const auto &II : Inputs) {
     if (II.isFilename())
       CmdArgs.push_back(II.getFilename());
     else
       // Don't render as input, we need gcc to do the translations.
       // FIXME: What is this?
       II.getInputArg().render(Args, CmdArgs);
   }
 
-  auto *Exec = Args.MakeArgString(HTC.GetProgramPath(AsName.c_str()));
+  auto Exec = Args.MakeArgString(HTC.GetProgramPath(AsName.c_str()));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void hexagon::Linker::RenderExtraToolArgs(const JobAction &JA,
                                           ArgStringList &CmdArgs) const {
 }
 
 static void

 void wasm::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                 const InputInfo &Output,
                                 const InputInfoList &Inputs,
                                 const ArgList &Args,
                                 StringRef LinkingOutput) const {
 
   const ToolChain &ToolChain = getToolChain();
   const Driver &D = ToolChain.getDriver();
-  const char *Linker = Args.MakeArgString(ToolChain.GetLinkerPath());
+  auto Linker = Args.MakeArgString(ToolChain.GetLinkerPath());
   ArgStringList CmdArgs;
   CmdArgs.push_back("-flavor");
   CmdArgs.push_back("ld");
 
   // Enable garbage collection of unused input sections by default, since code
   // size is of particular importance. This is significantly facilitated by
   // the enabling of -ffunction-sections and -fdata-sections in
   // Clang::ConstructJob.
void darwin::setTripleTypeForMachOArchName(llvm::Triple &T, StringRef Str) {
   else if (ArchKind == llvm::ARM::AK_ARMV6M ||
            ArchKind == llvm::ARM::AK_ARMV7M ||
            ArchKind == llvm::ARM::AK_ARMV7EM) {
     T.setOS(llvm::Triple::UnknownOS);
     T.setObjectFormat(llvm::Triple::MachO);
   }
 }
 
-const char *Clang::getBaseInputName(const ArgList &Args,
-                                    const InputInfo &Input) {
+StringRef Clang::getBaseInputName(const ArgList &Args, const InputInfo &Input) {
   return Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput()));
 }
 
-const char *Clang::getBaseInputStem(const ArgList &Args,
-                                    const InputInfoList &Inputs) {
-  const char *Str = getBaseInputName(Args, Inputs[0]);
-
-  if (const char *End = strrchr(Str, '.'))
-    return Args.MakeArgString(std::string(Str, End));
+StringRef Clang::getBaseInputStem(const ArgList &Args,
+  StringRef Str = getBaseInputName(Args, Inputs[0]);
+  auto DotPos = Str.find('.');
+  if (DotPos != StringRef::npos)
+    return Args.MakeArgString(Str.take_front(DotPos));
 
   return Str;
 }
 
-const char *Clang::getDependencyFileName(const ArgList &Args,
-                                         const InputInfoList &Inputs) {
+StringRef Clang::getDependencyFileName(const ArgList &Args,
   // FIXME: Think about this more.
   std::string Res;
 
   if (Arg *OutputOpt = Args.getLastArg(options::OPT_o)) {
     std::string Str(OutputOpt->getValue());
     Res = Str.substr(0, Str.rfind('.'));
   } else {
     Res = getBaseInputStem(Args, Inputs);
if (D.CCCIsCXX())
       ToolChain.AddCXXStdlibLibArgs(Args, CmdArgs);
     CmdArgs.push_back("-lc");
     CmdArgs.push_back("-lcompiler_rt");
   }
 
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles))
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
 
-  const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                      const InputInfo &Output,
                                      const InputInfoList &Inputs,
                                      const ArgList &Args,
                                      StringRef LinkingOutput) const {
void darwin::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   assert(Input.isFilename() && "Invalid input.");
   CmdArgs.push_back(Input.getFilename());
 
   // asm_final spec is empty.
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void darwin::MachOTool::anchor() {}
 
 void darwin::MachOTool::AddMachOArch(const ArgList &Args,
                                      ArgStringList &CmdArgs) const {
   StringRef ArchName = getMachOToolChain().getMachOArchName(Args);
if (Args.hasFlag(options::OPT_fapplication_extension,
                    options::OPT_fno_application_extension, false))
     CmdArgs.push_back("-application_extension");
 
   if (D.isUsingLTO()) {
     // If we are using LTO, then automatically create a temporary file path for
     // the linker to use, so that it's lifetime will extend past a possible
     // dsymutil step.
     if (Version[0] >= 116 && NeedsTempPath(Inputs)) {
-      const char *TmpPath = C.getArgs().MakeArgString(
+      StringRef TmpPath = C.getArgs().MakeArgString(
           D.GetTemporaryPath("cc", types::getTypeTempSuffix(types::TY_Object)));
       C.addTempFile(TmpPath);
       CmdArgs.push_back("-object_path_lto");
       CmdArgs.push_back(TmpPath);
     }
 
     // Use -lto_library option to specify the libLTO.dylib path. Try to find
     // it in clang installed libraries. If not found, the option is not used
void darwin::Linker::AddLinkArgs(Compilation &C, const ArgList &Args,
   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table);
   Args.AddAllArgs(CmdArgs, options::OPT_seg__addr__table__filename);
   Args.AddAllArgs(CmdArgs, options::OPT_sub__library);
   Args.AddAllArgs(CmdArgs, options::OPT_sub__umbrella);
 
   // Give --sysroot= preference, over the Apple specific behavior to also use
   // --isysroot as the syslibroot.
   StringRef sysroot = C.getSysRoot();
-  if (sysroot != "") {
+  if (!sysroot.empty()) {
     CmdArgs.push_back("-syslibroot");
     CmdArgs.push_back(C.getArgs().MakeArgString(sysroot));
   } else if (const Arg *A = Args.getLastArg(options::OPT_isysroot)) {
     CmdArgs.push_back("-syslibroot");
     CmdArgs.push_back(A->getValue());
   }
 
   Args.AddLastArg(CmdArgs, options::OPT_twolevel__namespace);
void darwin::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   // more information.
   ArgStringList CmdArgs;
 
   /// Hack(tm) to ignore linking errors when we are doing ARC migration.
   if (Args.hasArg(options::OPT_ccc_arcmt_check,
                   options::OPT_ccc_arcmt_migrate)) {
     for (const auto &Arg : Args)
       Arg->claim();
-    const char *Exec =
-        Args.MakeArgString(getToolChain().GetProgramPath("touch"));
+    StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("touch"));
     CmdArgs.push_back(Output.getFilename());
     C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, None));
     return;
   }
 
   // I'm not sure why this particular decomposition exists in gcc, but
   // we follow suite for ease of comparison.
   AddLinkArgs(C, Args, CmdArgs, Inputs);
if (isObjCRuntimeLinked(Args) &&
     CmdArgs.push_back("Foundation");
     // Link libobj.
     CmdArgs.push_back("-lobjc");
   }
 
   if (!LinkingOutput.empty()) {
     CmdArgs.push_back("-arch_multiple");
     CmdArgs.push_back("-final_output");
-    CmdArgs.push_back(LinkingOutput.data());
+    CmdArgs.push_back(LinkingOutput);
   }
 
   if (Args.hasArg(options::OPT_fnested_functions))
     CmdArgs.push_back("-allow_stack_execute");
 
   getMachOToolChain().addProfileRTLibs(Args, CmdArgs);
 
   if (unsigned Parallelism =
if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nodefaultlibs)) {
     if (Arg *A = Args.getLastArg(options::OPT_fveclib)) {
       if (A->getValue() == StringRef("Accelerate")) {
         CmdArgs.push_back("-framework");
         CmdArgs.push_back("Accelerate");
       }
     }
   }
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   std::unique_ptr<Command> Cmd =
       llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs);
   Cmd->setInputFileList(std::move(InputFileList));
   C.addCommand(std::move(Cmd));
 }
 
 void darwin::Lipo::ConstructJob(Compilation &C, const JobAction &JA,
                                 const InputInfo &Output,
                                 const InputInfoList &Inputs,
                                 const ArgList &Args,
                                 StringRef LinkingOutput) const {
   ArgStringList CmdArgs;
 
   CmdArgs.push_back("-create");
   assert(Output.isFilename() && "Unexpected lipo output.");
 
   CmdArgs.push_back("-output");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs) {
     assert(II.isFilename() && "Unexpected lipo input.");
     CmdArgs.push_back(II.getFilename());
   }
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("lipo"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void darwin::Dsymutil::ConstructJob(Compilation &C, const JobAction &JA,
                                     const InputInfo &Output,
                                     const InputInfoList &Inputs,
                                     const ArgList &Args,
                                     StringRef LinkingOutput) const {
   ArgStringList CmdArgs;
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
   const InputInfo &Input = Inputs[0];
   assert(Input.isFilename() && "Unexpected dsymutil input.");
   CmdArgs.push_back(Input.getFilename());
 
-  const char *Exec =
+  StringRef Exec =
       Args.MakeArgString(getToolChain().GetProgramPath("dsymutil"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void darwin::VerifyDebug::ConstructJob(Compilation &C, const JobAction &JA,
                                        const InputInfo &Output,
                                        const InputInfoList &Inputs,
                                        const ArgList &Args,
                                        StringRef LinkingOutput) const {
   ArgStringList CmdArgs;
   CmdArgs.push_back("--verify");
   CmdArgs.push_back("--debug-info");
   CmdArgs.push_back("--eh-frame");
   CmdArgs.push_back("--quiet");
 
   assert(Inputs.size() == 1 && "Unable to handle multiple inputs.");
   const InputInfo &Input = Inputs[0];
   assert(Input.isFilename() && "Unexpected verify input");
 
   // Grabbing the output of the earlier dsymutil run.
   CmdArgs.push_back(Input.getFilename());
 
-  const char *Exec =
+  StringRef Exec =
       Args.MakeArgString(getToolChain().GetProgramPath("dwarfdump"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void solaris::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                       const InputInfo &Output,
                                       const InputInfoList &Inputs,
                                       const ArgList &Args,
                                       StringRef LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                    const InputInfo &Output,
                                    const InputInfoList &Inputs,
                                    const ArgList &Args,
                                    StringRef LinkingOutput) const {
void solaris::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
     CmdArgs.push_back(
         Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
   }
   CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
 
   getToolChain().addProfileRTLibs(Args, CmdArgs);
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                       const InputInfo &Output,
                                       const InputInfoList &Inputs,
                                       const ArgList &Args,
                                       StringRef LinkingOutput) const {
void openbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void openbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                    const InputInfo &Output,
                                    const InputInfoList &Inputs,
                                    const ArgList &Args,
                                    StringRef LinkingOutput) const {
if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
     if (!Args.hasArg(options::OPT_shared))
       CmdArgs.push_back(
           Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
     else
       CmdArgs.push_back(
           Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
   }
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void bitrig::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                      const InputInfo &Output,
                                      const InputInfoList &Inputs,
                                      const ArgList &Args,
                                      StringRef LinkingOutput) const {
   claimNoWarnArgs(Args);
   ArgStringList CmdArgs;
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void bitrig::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                   const InputInfo &Output,
                                   const InputInfoList &Inputs,
                                   const ArgList &Args,
                                   StringRef LinkingOutput) const {
if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
     if (!Args.hasArg(options::OPT_shared))
       CmdArgs.push_back(
           Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
     else
       CmdArgs.push_back(
           Args.MakeArgString(getToolChain().GetFilePath("crtendS.o")));
   }
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void freebsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                       const InputInfo &Output,
                                       const InputInfoList &Inputs,
                                       const ArgList &Args,
                                       StringRef LinkingOutput) const {
void freebsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void freebsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                    const InputInfo &Output,
                                    const InputInfoList &Inputs,
                                    const ArgList &Args,
                                    StringRef LinkingOutput) const {
if (Args.hasArg(options::OPT_shared) || IsPIE)
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
     else
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
   }
 
   ToolChain.addProfileRTLibs(Args, CmdArgs);
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                      const InputInfo &Output,
                                      const InputInfoList &Inputs,
                                      const ArgList &Args,
                                      StringRef LinkingOutput) const {
void netbsd::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
-  const char *Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
+  StringRef Exec = Args.MakeArgString((getToolChain().GetProgramPath("as")));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void netbsd::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                   const InputInfo &Output,
                                   const InputInfoList &Inputs,
                                   const ArgList &Args,
                                   StringRef LinkingOutput) const {
if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
     else
       CmdArgs.push_back(
           Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
   }
 
   getToolChain().addProfileRTLibs(Args, CmdArgs);
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void gnutools::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                        const InputInfo &Output,
                                        const InputInfoList &Inputs,
                                        const ArgList &Args,
                                        StringRef LinkingOutput) const {
void gnutools::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 
   // Handle the debug info splitting at object creation time if we're
   // creating an object.
   // TODO: Currently only works on linux with newer objcopy.
   if (Args.hasArg(options::OPT_gsplit_dwarf) &&
       getToolChain().getTriple().isOSLinux())
     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
void gnutools::Linker::ConstructJob(Compilation &C, const JobAction &JA,
   // Silence warning for "clang -g foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_g_Group);
   // and "clang -emit-llvm foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   // and for "clang -w foo.o -o foo". Other warning options are already
   // handled somewhere else.
   Args.ClaimAllArgs(options::OPT_w);
 
-  const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
   if (llvm::sys::path::filename(Exec) == "lld") {
     CmdArgs.push_back("-flavor");
     CmdArgs.push_back("old-gnu");
     CmdArgs.push_back("-target");
     CmdArgs.push_back(Args.MakeArgString(getToolChain().getTripleString()));
   }
 
   if (!D.SysRoot.empty())
if (!Args.hasArg(options::OPT_nostartfiles)) {
       else
         crtend = "crtend.o";
 
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath(crtend)));
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
     }
   }
 
-  const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void fuchsia::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                    const InputInfo &Output,
                                    const InputInfoList &Inputs,
                                    const ArgList &Args,
                                    StringRef LinkingOutput) const {
   const toolchains::Fuchsia &ToolChain =
       static_cast<const toolchains::Fuchsia &>(getToolChain());
   const Driver &D = ToolChain.getDriver();
 
   ArgStringList CmdArgs;
 
   // Silence warning for "clang -g foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_g_Group);
   // and "clang -emit-llvm foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   // and for "clang -w foo.o -o foo". Other warning options are already
   // handled somewhere else.
   Args.ClaimAllArgs(options::OPT_w);
 
-  const char *Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(ToolChain.GetLinkerPath());
   if (llvm::sys::path::filename(Exec).equals_lower("lld")) {
     CmdArgs.push_back("-flavor");
     CmdArgs.push_back("gnu");
   }
 
   if (!D.SysRoot.empty())
     CmdArgs.push_back(Args.MakeArgString("--sysroot=" + D.SysRoot));
 
void minix::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void minix::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                  const InputInfo &Output,
                                  const InputInfoList &Inputs,
                                  const ArgList &Args,
                                  StringRef LinkingOutput) const {
if (Args.hasArg(options::OPT_pthread))
       CmdArgs.push_back("-lpthread");
     CmdArgs.push_back("-lc");
     CmdArgs.push_back("-lCompilerRT-Generic");
     CmdArgs.push_back("-L/usr/pkg/compiler-rt/lib");
     CmdArgs.push_back(
         Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
   }
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 /// DragonFly Tools
 
 // For now, DragonFly Assemble does just about the same as for
 // FreeBSD, but this may change soon.
 void dragonfly::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
void dragonfly::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void dragonfly::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                      const InputInfo &Output,
                                      const InputInfoList &Inputs,
                                      const ArgList &Args,
                                      StringRef LinkingOutput) const {
if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
     else
       CmdArgs.push_back(
           Args.MakeArgString(getToolChain().GetFilePath("crtend.o")));
     CmdArgs.push_back(Args.MakeArgString(getToolChain().GetFilePath("crtn.o")));
   }
 
   getToolChain().addProfileRTLibs(Args, CmdArgs);
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
+  StringRef Exec = Args.MakeArgString(getToolChain().GetLinkerPath());
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 // Try to find Exe from a Visual Studio distribution.  This first tries to find
 // an installed copy of Visual Studio and, failing that, looks in the PATH,
 // making sure that whatever executable that's found is not a same-named exe
 // from clang itself to prevent clang from falling back to itself.
 static std::string FindVisualStudioExecutable(const ToolChain &TC,
if (Input.isFilename()) {
       continue;
     }
 
     const Arg &A = Input.getInputArg();
 
     // Render -l options differently for the MSVC linker.
     if (A.getOption().matches(options::OPT_l)) {
       StringRef Lib = A.getValue();
-      const char *LinkLibArg;
+      StringRef LinkLibArg;
       if (Lib.endswith(".lib"))
         LinkLibArg = Args.MakeArgString(Lib);
       else
         LinkLibArg = Args.MakeArgString(Lib + ".lib");
       CmdArgs.push_back(LinkLibArg);
       continue;
     }
 
if (Linker.equals_lower("link")) {
     linkPath = FindVisualStudioExecutable(TC, "link.exe",
                                           C.getDriver().getClangProgramPath());
   } else {
     linkPath = Linker;
     llvm::sys::path::replace_extension(linkPath, "exe");
     linkPath = TC.GetProgramPath(linkPath.c_str());
   }
 
-  const char *Exec = Args.MakeArgString(linkPath);
+  StringRef Exec = Args.MakeArgString(linkPath);
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void visualstudio::Compiler::ConstructJob(Compilation &C, const JobAction &JA,
                                           const InputInfo &Output,
                                           const InputInfoList &Inputs,
                                           const ArgList &Args,
                                           StringRef LinkingOutput) const {
std::unique_ptr<Command> visualstudio::Compiler::GetCommand(
   CmdArgs.push_back(II.getType() == types::TY_C ? "/Tc" : "/Tp");
   if (II.isFilename())
     CmdArgs.push_back(II.getFilename());
   else
     II.getInputArg().renderAsInput(Args, CmdArgs);
 
   // Output filename.
   assert(Output.getType() == types::TY_Object);
-  const char *Fo =
-      Args.MakeArgString(std::string("/Fo") + Output.getFilename());
+  StringRef Fo = Args.MakeArgString(std::string("/Fo") + Output.getFilename());
   CmdArgs.push_back(Fo);
 
   const Driver &D = getToolChain().getDriver();
   std::string Exec = FindVisualStudioExecutable(getToolChain(), "cl.exe",
                                                 D.getClangProgramPath());
   return llvm::make_unique<Command>(JA, *this, Args.MakeArgString(Exec),
                                     CmdArgs, Inputs);
 }
void MinGW::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 
   if (Args.hasArg(options::OPT_gsplit_dwarf))
     SplitDebugInfo(getToolChain(), C, *this, JA, Args, Output,
                    SplitDebugName(Args, Inputs[0]));
 }
 
 void MinGW::Linker::AddLibGCC(const ArgList &Args,
if (!Args.hasArg(options::OPT_nostdlib)) {
 
     if (!Args.hasArg(options::OPT_nostartfiles)) {
       // Add crtfastmath.o if available and fast math is enabled.
       TC.AddFastMathRuntimeIfAvailable(Args, CmdArgs);
 
       CmdArgs.push_back(Args.MakeArgString(TC.GetFilePath("crtend.o")));
     }
   }
-  const char *Exec = Args.MakeArgString(TC.GetProgramPath(LinkerName.data()));
+  StringRef Exec = Args.MakeArgString(TC.GetProgramPath(LinkerName));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 /// XCore Tools
 // We pass assemble and link construction to the xcc tool.
 
 void XCore::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                     const InputInfo &Output,
if (Args.hasFlag(options::OPT_fverbose_asm, options::OPT_fno_verbose_asm,
                    false))
     CmdArgs.push_back("-fverbose-asm");
 
   Args.AddAllArgValues(CmdArgs, options::OPT_Wa_COMMA, options::OPT_Xassembler);
 
   for (const auto &II : Inputs)
     CmdArgs.push_back(II.getFilename());
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void XCore::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                  const InputInfo &Output,
                                  const InputInfoList &Inputs,
                                  const ArgList &Args,
                                  StringRef LinkingOutput) const {
void XCore::Linker::ConstructJob(Compilation &C, const JobAction &JA,
 
   // Pass -fexceptions through to the linker if it was present.
   if (Args.hasFlag(options::OPT_fexceptions, options::OPT_fno_exceptions,
                    false))
     CmdArgs.push_back("-fexceptions");
 
   AddLinkerInputs(getToolChain(), Inputs, Args, CmdArgs);
 
-  const char *Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
+  StringRef Exec = Args.MakeArgString(getToolChain().GetProgramPath("xcc"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 void CrossWindows::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
                                            const InputInfo &Output,
                                            const InputInfoList &Inputs,
                                            const ArgList &Args,
                                            StringRef LinkingOutput) const {
   claimNoWarnArgs(Args);
   const auto &TC =
       static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
   ArgStringList CmdArgs;
-  const char *Exec;
+  StringRef Exec;
 
   switch (TC.getArch()) {
   default:
     llvm_unreachable("unsupported architecture");
   case llvm::Triple::arm:
   case llvm::Triple::thumb:
     break;
   case llvm::Triple::x86:
void CrossWindows::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                         const ArgList &Args,
                                         StringRef LinkingOutput) const {
   const auto &TC =
       static_cast<const toolchains::CrossWindowsToolChain &>(getToolChain());
   const llvm::Triple &T = TC.getTriple();
   const Driver &D = TC.getDriver();
   SmallString<128> EntryPoint;
   ArgStringList CmdArgs;
-  const char *Exec;
+  StringRef Exec;
 
   // Silence warning for "clang -g foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_g_Group);
   // and "clang -emit-llvm foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_emit_llvm);
   // and for "clang -w foo.o -o foo"
   Args.ClaimAllArgs(options::OPT_w);
   // Other warning options are already handled somewhere else.
void PS4cpu::Assemble::ConstructJob(Compilation &C, const JobAction &JA,
   CmdArgs.push_back("-o");
   CmdArgs.push_back(Output.getFilename());
 
   assert(Inputs.size() == 1 && "Unexpected number of inputs.");
   const InputInfo &Input = Inputs[0];
   assert(Input.isFilename() && "Invalid input.");
   CmdArgs.push_back(Input.getFilename());
 
-  const char *Exec =
+  StringRef Exec =
       Args.MakeArgString(getToolChain().GetProgramPath("orbis-as"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 static void AddPS4SanitizerArgs(const ToolChain &TC, ArgStringList &CmdArgs) {
   const SanitizerArgs &SanArgs = TC.getSanitizerArgs();
   if (SanArgs.needsUbsanRt()) {
     CmdArgs.push_back("-lSceDbgUBSanitizer_stub_weak");
if (Args.hasArg(options::OPT_Z_Xlinker__no_demangle))
     CmdArgs.push_back("--no-demangle");
 
   AddLinkerInputs(ToolChain, Inputs, Args, CmdArgs);
 
   if (Args.hasArg(options::OPT_pthread)) {
     CmdArgs.push_back("-lpthread");
   }
 
-  const char *Exec = Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
+  StringRef Exec = Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
 
   C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
 }
 
 static void ConstructGoldLinkJob(const Tool &T, Compilation &C,
                                  const JobAction &JA, const InputInfo &Output,
                                  const InputInfoList &Inputs,
                                  const ArgList &Args,
static void ConstructGoldLinkJob(const Tool &T, Compilation &C,
   if (!Args.hasArg(options::OPT_nostdlib, options::OPT_nostartfiles)) {
     if (Args.hasArg(options::OPT_shared) || Args.hasArg(options::OPT_pie))
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtendS.o")));
     else
       CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtend.o")));
     CmdArgs.push_back(Args.MakeArgString(ToolChain.GetFilePath("crtn.o")));
   }
 
-  const char *Exec =
+  StringRef Exec =
 #ifdef LLVM_ON_WIN32
       Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld.gold"));
 #else
       Args.MakeArgString(ToolChain.GetProgramPath("orbis-ld"));
 #endif
 
   C.addCommand(llvm::make_unique<Command>(JA, T, Exec, CmdArgs, Inputs));
 }
void NVPTX::Assembler::ConstructJob(Compilation &C, const JobAction &JA,
   CmdArgs.push_back("--output-file");
   CmdArgs.push_back(Args.MakeArgString(Output.getFilename()));
   for (const auto& II : Inputs)
     CmdArgs.push_back(Args.MakeArgString(II.getFilename()));
 
   for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_ptxas))
     CmdArgs.push_back(Args.MakeArgString(A));
 
-  const char *Exec = Args.MakeArgString(TC.GetProgramPath("ptxas"));
+  StringRef Exec = Args.MakeArgString(TC.GetProgramPath("ptxas"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }
 
 // All inputs to this linker must be from CudaDeviceActions, as we need to look
 // at the Inputs' Actions in order to figure out which GPU architecture they
 // correspond to.
 void NVPTX::Linker::ConstructJob(Compilation &C, const JobAction &JA,
                                  const InputInfo &Output,
const char *Arch =
             : gpu_arch_str;
     CmdArgs.push_back(Args.MakeArgString(llvm::Twine("--image=profile=") +
                                          Arch + ",file=" + II.getFilename()));
   }
 
   for (const auto& A : Args.getAllArgValues(options::OPT_Xcuda_fatbinary))
     CmdArgs.push_back(Args.MakeArgString(A));
 
-  const char *Exec = Args.MakeArgString(TC.GetProgramPath("fatbinary"));
+  StringRef Exec = Args.MakeArgString(TC.GetProgramPath("fatbinary"));
   C.addCommand(llvm::make_unique<Command>(JA, *this, Exec, CmdArgs, Inputs));
 }

clang/lib/Driver/Types.cpp

return llvm::StringSwitch<types::ID>(Ext)
            .Case("pch", TY_PCH)
            .Case("pcm", TY_ModuleFile)
            .Case("c++m", TY_CXXModule)
            .Case("cppm", TY_CXXModule)
            .Case("cxxm", TY_CXXModule)
            .Default(TY_INVALID);
 }
 
-types::ID types::lookupTypeForTypeSpecifier(const char *Name) {
+types::ID types::lookupTypeForTypeSpecifier(llvm::StringRef Name) {
   for (unsigned i=0; i<numTypes; ++i) {
     types::ID Id = (types::ID) (i + 1);
-    if (canTypeBeUserSpecified(Id) &&
-        strcmp(Name, getInfo(Id).Name) == 0)
+    if (canTypeBeUserSpecified(Id) && Name == getInfo(Id).Name)
       return Id;
   }
 
   return TY_INVALID;
 }
 
 // FIXME: Why don't we just put this list in the defs file, eh.
 void types::getCompilationPhases(ID Id, llvm::SmallVectorImpl<phases::ID> &P) {

clang/lib/Frontend/CompilerInvocation.cpp

if (A->getOption().getKind() == Option::FlagClass) {
       // The argument is a pure flag (such as OPT_Wall or OPT_Wdeprecated). Add
       // its name (minus the "W" or "R" at the beginning) to the warning list.
       Diagnostics.push_back(A->getOption().getName().drop_front(1));
     } else if (A->getOption().matches(GroupWithValue)) {
       // This is -Wfoo= or -Rfoo=, where foo is the name of the diagnostic group.
       Diagnostics.push_back(A->getOption().getName().drop_front(1).rtrim("=-"));
     } else {
       // Otherwise, add its value (for OPT_W_Joined and similar).
-      for (const char *Arg : A->getValues())
+      for (StringRef Arg : A->getValues())
         Diagnostics.emplace_back(Arg);
     }
   }
 }
 
 static void getAllNoBuiltinFuncValues(ArgList &Args,
                                       std::vector<std::string> &Funcs) {
-  SmallVector<const char *, 8> Values;
   for (const auto &Arg : Args) {
     const Option &O = Arg->getOption();
     if (O.matches(options::OPT_fno_builtin_)) {
-      const char *FuncName = Arg->getValue();
+      StringRef FuncName = Arg->getValue();
       if (Builtin::Context::isBuiltinFunc(FuncName))
-        Values.push_back(FuncName);
+        Funcs.push_back(FuncName);
     }
   }
-  Funcs.insert(Funcs.end(), Values.begin(), Values.end());
 }
 
 static bool ParseAnalyzerArgs(AnalyzerOptions &Opts, ArgList &Args,
                               DiagnosticsEngine &Diags) {
   using namespace options;
   bool Success = true;
   if (Arg *A = Args.getLastArg(OPT_analyzer_store)) {
     StringRef Name = A->getValue();
if (IK == IK_None) {
         DashX = IK;
     }
     Opts.Inputs.emplace_back(std::move(Inputs[i]), IK);
   }
 
   return DashX;
 }
 
-std::string CompilerInvocation::GetResourcesPath(const char *Argv0,
+std::string CompilerInvocation::GetResourcesPath(StringRef Argv0,
                                                  void *MainAddr) {
   std::string ClangExecutable =
-      llvm::sys::fs::getMainExecutable(Argv0, MainAddr);
+      llvm::sys::fs::getMainExecutable(Argv0.str().c_str(), MainAddr);
   StringRef Dir = llvm::sys::path::parent_path(ClangExecutable);
 
   // Compute the path to the resource directory.
   StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
   SmallString<128> P(Dir);
   if (ClangResourceDir != "")
     llvm::sys::path::append(P, ClangResourceDir);
   else
     llvm::sys::path::append(P, "..", Twine("lib") + CLANG_LIBDIR_SUFFIX,
                             "clang", CLANG_VERSION_STRING);
 
   return P.str();
 }
 
 static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) {
   using namespace options;
   Opts.Sysroot = Args.getLastArgValue(OPT_isysroot, "/");
   Opts.Verbose = Args.hasArg(OPT_v);
   Opts.UseBuiltinIncludes = !Args.hasArg(OPT_nobuiltininc);
   Opts.UseStandardSystemIncludes = !Args.hasArg(OPT_nostdsysteminc);
   Opts.UseStandardCXXIncludes = !Args.hasArg(OPT_nostdincxx);
   if (const Arg *A = Args.getLastArg(OPT_stdlib_EQ))
-    Opts.UseLibcxx = (strcmp(A->getValue(), "libc++") == 0);
+    Opts.UseLibcxx = A->getValue() == "libc++";
   Opts.ResourceDir = Args.getLastArgValue(OPT_resource_dir);
   Opts.ModuleCachePath = Args.getLastArgValue(OPT_fmodules_cache_path);
   Opts.ModuleUserBuildPath = Args.getLastArgValue(OPT_fmodules_user_build_path);
   for (const Arg *A : Args.filtered(OPT_fprebuilt_module_path))
     Opts.AddPrebuiltModulePath(A->getValue());
   Opts.DisableModuleHash = Args.hasArg(OPT_fdisable_module_hash);
   Opts.ModulesValidateDiagnosticOptions =
       !Args.hasArg(OPT_fmodules_disable_diagnostic_validation);
static void ParseHeaderSearchArgs(HeaderSearchOptions &Opts, ArgList &Args) {
 
   // Add -iprefix/-iwithprefix/-iwithprefixbefore options.
   StringRef Prefix = ""; // FIXME: This isn't the correct default prefix.
   for (const Arg *A :
        Args.filtered(OPT_iprefix, OPT_iwithprefix, OPT_iwithprefixbefore)) {
     if (A->getOption().matches(OPT_iprefix))
       Prefix = A->getValue();
     else if (A->getOption().matches(OPT_iwithprefix))
-      Opts.AddPath(Prefix.str() + A->getValue(), frontend::After, false, true);
+      Opts.AddPath((Prefix + A->getValue()).str(), frontend::After, false,
+                   true);
     else
-      Opts.AddPath(Prefix.str() + A->getValue(), frontend::Angled, false, true);
+      Opts.AddPath((Prefix + A->getValue()).str(), frontend::Angled, false,
+                   true);
   }
 
   for (const Arg *A : Args.filtered(OPT_idirafter))
     Opts.AddPath(A->getValue(), frontend::After, false, true);
   for (const Arg *A : Args.filtered(OPT_iquote))
     Opts.AddPath(A->getValue(), frontend::Quoted, false, true);
   for (const Arg *A : Args.filtered(OPT_isystem, OPT_iwithsysroot))
     Opts.AddPath(A->getValue(), frontend::System, false,
static void ParseTargetArgs(TargetOptions &Opts, ArgList &Args,
   if (Opts.Triple.empty())
     Opts.Triple = llvm::sys::getDefaultTargetTriple();
 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
                                         const char *const *ArgBegin,
                                         const char *const *ArgEnd,
                                         DiagnosticsEngine &Diags) {
+  SmallVector<StringRef, 32> ArgsStr;
+  for (const char *const *Arg = ArgBegin; Arg != ArgEnd; ++Arg)
+    ArgsStr.push_back(StringRef(*Arg));
+  return CreateFromArgs(Res, ArgsStr.begin(), ArgsStr.end(), Diags);
+}
+
+bool CompilerInvocation::CreateFromArgs(CompilerInvocation &Res,
+                                        const StringRef *ArgBegin,
+                                        const StringRef *ArgEnd,
+                                        DiagnosticsEngine &Diags) {
   bool Success = true;
 
   // 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,

clang/lib/Frontend/CreateInvocationFromCommandLine.cpp

 clang::createInvocationFromCommandLine(ArrayRef<const char *> ArgList,
                             IntrusiveRefCntPtr<DiagnosticsEngine> Diags) {
   if (!Diags.get()) {
     // No diagnostics engine was provided, so create our own diagnostics object
     // with the default options.
     Diags = CompilerInstance::createDiagnostics(new DiagnosticOptions);
   }
 
-  SmallVector<const char *, 16> Args(ArgList.begin(), ArgList.end());
+  SmallVector<StringRef, 16> Args(ArgList.begin(), ArgList.end());
 
   // FIXME: Find a cleaner way to force the driver into restricted modes.
   Args.push_back("-fsyntax-only");
 
   // FIXME: We shouldn't have to pass in the path info.
   driver::Driver TheDriver(Args[0], llvm::sys::getDefaultTargetTriple(),
                            *Diags);
 
clang::createInvocationFromCommandLine(ArrayRef<const char *> ArgList,
   }
 
   const driver::Command &Cmd = cast<driver::Command>(*Jobs.begin());
   if (StringRef(Cmd.getCreator().getName()) != "clang") {
     Diags->Report(diag::err_fe_expected_clang_command);
     return nullptr;
   }
 
-  const ArgStringList &CCArgs = Cmd.getArguments();
+  auto &CCArgs = Cmd.getArguments();
   std::unique_ptr<CompilerInvocation> CI(new CompilerInvocation());
   if (!CompilerInvocation::CreateFromArgs(*CI,
-                                     const_cast<const char **>(CCArgs.data()),
-                                     const_cast<const char **>(CCArgs.data()) +
-                                     CCArgs.size(),
+                                     CCArgs.begin(), CCArgs.end(),
                                      *Diags))
     return nullptr;
   return CI.release();
 }

clang/lib/Tooling/CompilationDatabase.cpp

 /// clang::driver::Driver although what the interface should look like is not
 /// clear.
 ///
 /// \param[in] Args Args as provided by the user.
 /// \return Resulting stripped command line.
 ///          \li true if successful.
 ///          \li false if \c Args cannot be used for compilation jobs (e.g.
 ///          contains an option like -E or -version).
-static bool stripPositionalArgs(std::vector<const char *> Args,
+static bool stripPositionalArgs(std::vector<StringRef> Args,
                                 std::vector<std::string> &Result) {
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   UnusedInputDiagConsumer DiagClient;
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<clang::DiagnosticIDs>(new DiagnosticIDs()),
       &*DiagOpts, &DiagClient, false);
 
   // The clang executable path isn't required since the jobs the driver builds
if (CompileAnalyzer.Inputs.empty()) {
     // No compile jobs found.
     // FIXME: Emit a warning of some kind?
     return false;
   }
 
   // Remove all compilation input files from the command line. This is
   // necessary so that getCompileCommands() can construct a command line for
   // each file.
-  std::vector<const char *>::iterator End = std::remove_if(
+  std::vector<StringRef>::iterator End = std::remove_if(
       Args.begin(), Args.end(), MatchesAny(CompileAnalyzer.Inputs));
 
   // Remove all inputs deemed unused for compilation.
   End = std::remove_if(Args.begin(), End, MatchesAny(DiagClient.UnusedInputs));
 
   // Remove the -c add above as well. It will be at the end right now.
-  assert(strcmp(*(End - 1), "-c") == 0);
     --End;
+  assert(*End == "-c");
 
   Result = std::vector<std::string>(Args.begin() + 1, End);
   return true;
 }
 
 FixedCompilationDatabase *FixedCompilationDatabase::loadFromCommandLine(
     int &Argc, const char *const *Argv, Twine Directory) {
   const char *const *DoubleDash = std::find(Argv, Argv + Argc, StringRef("--"));
   if (DoubleDash == Argv + Argc)
     return nullptr;
-  std::vector<const char *> CommandLine(DoubleDash + 1, Argv + Argc);
+  std::vector<StringRef> CommandLine;
+  CommandLine.reserve(Argv + Argc - DoubleDash - 1);
+  for (auto Arg : ArrayRef<const char *>(DoubleDash + 1, Argv + Argc))
+    CommandLine.push_back(Arg);
+
   Argc = DoubleDash - Argv;
 
   std::vector<std::string> StrippedArgs;
   if (!stripPositionalArgs(CommandLine, StrippedArgs))
     return nullptr;
   return new FixedCompilationDatabase(Directory, StrippedArgs);
 }
 

clang/lib/Tooling/JSONCompilationDatabase.cpp

if (Triple.getOS() == llvm::Triple::OSType::Win32) {
           Triple.getEnvironment() == llvm::Triple::EnvironmentType::MSVC)
         Syntax = JSONCommandLineSyntax::Windows;
     }
   }
 
   if (Syntax == JSONCommandLineSyntax::Windows) {
     llvm::BumpPtrAllocator Alloc;
     llvm::StringSaver Saver(Alloc);
-    llvm::SmallVector<const char *, 64> T;
+    llvm::SmallVector<StringRef, 64> T;
     llvm::cl::TokenizeWindowsCommandLine(EscapedCommandLine, Saver, T);
-    std::vector<std::string> Result(T.begin(), T.end());
+    std::vector<std::string> Result;
+    for (StringRef Token : T)
+      Result.push_back(Token);
     return Result;
   }
   assert(Syntax == JSONCommandLineSyntax::Gnu);
   CommandLineArgumentParser parser(EscapedCommandLine);
   return parser.parse();
 }
 
 class JSONCompilationDatabasePlugin : public CompilationDatabasePlugin {

clang/lib/Tooling/Tooling.cpp

 
 FrontendActionFactory::~FrontendActionFactory() {}
 
 // FIXME: This file contains structural duplication with other parts of the
 // code that sets up a compiler to run tools on it, and we should refactor
 // it to be based on the same framework.
 
 /// \brief Builds a clang driver initialized for running clang tools.
-static clang::driver::Driver *newDriver(
-    clang::DiagnosticsEngine *Diagnostics, const char *BinaryName,
+static clang::driver::Driver *
+newDriver(clang::DiagnosticsEngine *Diagnostics, StringRef BinaryName,
           IntrusiveRefCntPtr<vfs::FileSystem> VFS) {
   clang::driver::Driver *CompilerDriver =
       new clang::driver::Driver(BinaryName, llvm::sys::getDefaultTargetTriple(),
                                 *Diagnostics, std::move(VFS));
   CompilerDriver->setTitle("clang_based_tool");
   return CompilerDriver;
 }
 
 /// \brief Retrieves the clang CC1 specific flags out of the compilation's jobs.

 
 void ToolInvocation::mapVirtualFile(StringRef FilePath, StringRef Content) {
   SmallString<1024> PathStorage;
   llvm::sys::path::native(FilePath, PathStorage);
   MappedFileContents[PathStorage] = Content;
 }
 
 bool ToolInvocation::run() {
-  std::vector<const char*> Argv;
+  std::vector<StringRef> Argv;
   for (const std::string &Str : CommandLine)
-    Argv.push_back(Str.c_str());
-  const char *const BinaryName = Argv[0];
+    Argv.push_back(Str);
+  StringRef BinaryName(Argv[0]);
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   unsigned MissingArgIndex, MissingArgCount;
   std::unique_ptr<llvm::opt::OptTable> Opts(driver::createDriverOptTable());
   llvm::opt::InputArgList ParsedArgs = Opts->ParseArgs(
-      ArrayRef<const char *>(Argv).slice(1), MissingArgIndex, MissingArgCount);
+      ArrayRef<StringRef>(Argv).slice(1), MissingArgIndex, MissingArgCount);
   ParseDiagnosticArgs(*DiagOpts, ParsedArgs);
   TextDiagnosticPrinter DiagnosticPrinter(
       llvm::errs(), &*DiagOpts);
   DiagnosticsEngine Diagnostics(
       IntrusiveRefCntPtr<clang::DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
       DiagConsumer ? DiagConsumer : &DiagnosticPrinter, false);
 
   const std::unique_ptr<clang::driver::Driver> Driver(
for (const auto &It : MappedFileContents) {
     Invocation->getPreprocessorOpts().addRemappedFile(It.getKey(),
                                                       Input.release());
   }
   return runInvocation(BinaryName, Compilation.get(), Invocation.release(),
                        std::move(PCHContainerOps));
 }
 
 bool ToolInvocation::runInvocation(
-    const char *BinaryName, clang::driver::Compilation *Compilation,
+    StringRef BinaryName, clang::driver::Compilation *Compilation,
     clang::CompilerInvocation *Invocation,
     std::shared_ptr<PCHContainerOperations> PCHContainerOps) {
   // Show the invocation, with -v.
   if (Invocation->getHeaderSearchOpts().Verbose) {
     llvm::errs() << "clang Invocation:\n";
     Compilation->getJobs().Print(llvm::errs(), "\n", true);
     llvm::errs() << "\n";
   }

clang/tools/driver/cc1_main.cpp

static void ensureSufficientStack() {
   // We should now have a stack of size at least kSufficientStack. Ensure
   // that we can actually use that much, if necessary.
   ensureStackAddressSpace();
 }
 #else
 static void ensureSufficientStack() {}
 #endif
 
-int cc1_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
+int cc1_main(ArrayRef<StringRef> Argv, StringRef Argv0, void *MainAddr) {
   ensureSufficientStack();
 
   std::unique_ptr<CompilerInstance> Clang(new CompilerInstance());
   IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
 
   // Register the support for object-file-wrapped Clang modules.
   auto PCHOps = Clang->getPCHContainerOperations();
   PCHOps->registerWriter(llvm::make_unique<ObjectFilePCHContainerWriter>());

clang/tools/driver/cc1as_main.cpp

AssemblerInvocation() {
     ShowEncoding = 0;
     RelaxAll = 0;
     NoExecStack = 0;
     FatalWarnings = 0;
     IncrementalLinkerCompatible = 0;
     DwarfVersion = 0;
   }
 
-  static bool CreateFromArgs(AssemblerInvocation &Res,
-                             ArrayRef<const char *> Argv,
+  static bool CreateFromArgs(AssemblerInvocation &Res, ArrayRef<StringRef> Argv,
                              DiagnosticsEngine &Diags);
 };
 
 }
 
 bool AssemblerInvocation::CreateFromArgs(AssemblerInvocation &Opts,
-                                         ArrayRef<const char *> Argv,
+                                         ArrayRef<StringRef> Argv,
                                          DiagnosticsEngine &Diags) {
   bool Success = true;
 
   // Parse the arguments.
   std::unique_ptr<OptTable> OptTbl(createDriverOptTable());
 
   const unsigned IncludedFlagsBitmask = options::CC1AsOption;
   unsigned MissingArgIndex, MissingArgCount;
static void LLVMErrorHandler(void *UserData, const std::string &Message,
   DiagnosticsEngine &Diags = *static_cast<DiagnosticsEngine*>(UserData);
 
   Diags.Report(diag::err_fe_error_backend) << Message;
 
   // We cannot recover from llvm errors.
   exit(1);
 }
 
-int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0, void *MainAddr) {
+int cc1as_main(ArrayRef<StringRef> Argv, StringRef Argv0, void *MainAddr) {
   // Initialize targets and assembly printers/parsers.
   InitializeAllTargetInfos();
   InitializeAllTargetMCs();
   InitializeAllAsmParsers();
 
   // Construct our diagnostic client.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
   TextDiagnosticPrinter *DiagClient

clang/tools/driver/driver.cpp

 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 #include <set>
 #include <system_error>
 using namespace clang;
 using namespace clang::driver;
 using namespace llvm::opt;
 
-std::string GetExecutablePath(const char *Argv0, bool CanonicalPrefixes) {
+std::string GetExecutablePath(StringRef Argv0, bool CanonicalPrefixes) {
   if (!CanonicalPrefixes)
     return Argv0;
 
   // This just needs to be some symbol in the binary; C++ doesn't
   // allow taking the address of ::main however.
   void *P = (void*) (intptr_t) GetExecutablePath;
-  return llvm::sys::fs::getMainExecutable(Argv0, P);
+  return llvm::sys::fs::getMainExecutable(Argv0.str().c_str(), P);
 }
 
 static const char *GetStableCStr(std::set<std::string> &SavedStrings,
                                  StringRef S) {
   return SavedStrings.insert(S).first->c_str();
 }
 
 /// ApplyQAOverride - Apply a list of edits to the input argument lists.

 ///  'Ox': Removes all flags matching 'O' or 'O[sz0-9]' and adds 'Ox'
 ///  at the end of the command line.
 ///
 /// \param OS - The stream to write edit information to.
 /// \param Args - The vector of command line arguments.
 /// \param Edit - The override command to perform.
 /// \param SavedStrings - Set to use for storing string representations.
 static void ApplyOneQAOverride(raw_ostream &OS,
-                               SmallVectorImpl<const char*> &Args,
-                               StringRef Edit,
+                               SmallVectorImpl<StringRef> &Args, StringRef Edit,
                                std::set<std::string> &SavedStrings) {
   // This does not need to be efficient.
 
   if (Edit[0] == '^') {
     const char *Str =
       GetStableCStr(SavedStrings, Edit.substr(1));
     OS << "### Adding argument " << Str << " at beginning\n";
     Args.insert(Args.begin() + 1, Str);
   } else if (Edit[0] == '+') {
     const char *Str =
       GetStableCStr(SavedStrings, Edit.substr(1));
     OS << "### Adding argument " << Str << " at end\n";
     Args.push_back(Str);
   } else if (Edit[0] == 's' && Edit[1] == '/' && Edit.endswith("/") &&
              Edit.slice(2, Edit.size()-1).find('/') != StringRef::npos) {
     StringRef MatchPattern = Edit.substr(2).split('/').first;
     StringRef ReplPattern = Edit.substr(2).split('/').second;
     ReplPattern = ReplPattern.slice(0, ReplPattern.size()-1);
 
     for (unsigned i = 1, e = Args.size(); i != e; ++i) {
       // Ignore end-of-line response file markers
-      if (Args[i] == nullptr)
+      if (Args[i].empty())
         continue;
       std::string Repl = llvm::Regex(MatchPattern).sub(ReplPattern, Args[i]);
 
       if (Repl != Args[i]) {
         OS << "### Replacing '" << Args[i] << "' with '" << Repl << "'\n";
         Args[i] = GetStableCStr(SavedStrings, Repl);
       }
     }
for (unsigned i = 1; i < Args.size();) {
           } else
             OS << "### Invalid X edit, end of command line!\n";
         }
       } else
         ++i;
     }
   } else if (Edit[0] == 'O') {
     for (unsigned i = 1; i < Args.size();) {
-      const char *A = Args[i];
+      StringRef A = Args[i];
       // Ignore end-of-line response file markers
-      if (A == nullptr)
+      if (A.empty())
         continue;
       if (A[0] == '-' && A[1] == 'O' &&
-          (A[2] == '\0' ||
-           (A[3] == '\0' && (A[2] == 's' || A[2] == 'z' ||
-                             ('0' <= A[2] && A[2] <= '9'))))) {
+          (A.size() == 2 ||
+           (A.size() == 3 &&
+            (A[2] == 's' || A[2] == 'z' || ('0' <= A[2] && A[2] <= '9'))))) {
         OS << "### Deleting argument " << Args[i] << '\n';
         Args.erase(Args.begin() + i);
       } else
         ++i;
     }
     OS << "### Adding argument " << Edit << " at end\n";
     Args.push_back(GetStableCStr(SavedStrings, '-' + Edit.str()));
   } else {
     OS << "### Unrecognized edit: " << Edit << "\n";
   }
 }
 
 /// ApplyQAOverride - Apply a comma separate list of edits to the
 /// input argument lists. See ApplyOneQAOverride.
-static void ApplyQAOverride(SmallVectorImpl<const char*> &Args,
+static void ApplyQAOverride(SmallVectorImpl<StringRef> &Args,
                             const char *OverrideStr,
                             std::set<std::string> &SavedStrings) {
   raw_ostream *OS = &llvm::errs();
 
   if (OverrideStr[0] == '#') {
     ++OverrideStr;
     OS = &llvm::nulls();
   }
while (*S) {
     if (End != S)
       ApplyOneQAOverride(*OS, Args, std::string(S, End), SavedStrings);
     S = End;
     if (*S != '\0')
       ++S;
   }
 }
 
-extern int cc1_main(ArrayRef<const char *> Argv, const char *Argv0,
-                    void *MainAddr);
-extern int cc1as_main(ArrayRef<const char *> Argv, const char *Argv0,
+extern int cc1_main(ArrayRef<StringRef> Argv, StringRef Argv0, void *MainAddr);
+extern int cc1as_main(ArrayRef<StringRef> Argv, StringRef Argv0,
                       void *MainAddr);
 
 static void insertTargetAndModeArgs(StringRef Target, StringRef Mode,
-                                    SmallVectorImpl<const char *> &ArgVector,
+                                    SmallVectorImpl<StringRef> &ArgVector,
                                     std::set<std::string> &SavedStrings) {
   if (!Mode.empty()) {
     // Add the mode flag to the arguments.
     auto it = ArgVector.begin();
     if (it != ArgVector.end())
       ++it;
     ArgVector.insert(it, GetStableCStr(SavedStrings, Mode));
   }
 
   if (!Target.empty()) {
     auto it = ArgVector.begin();
     if (it != ArgVector.end())
       ++it;
     const char *arr[] = {"-target", GetStableCStr(SavedStrings, Target)};
     ArgVector.insert(it, std::begin(arr), std::end(arr));
   }
 }
 
 static void getCLEnvVarOptions(std::string &EnvValue, llvm::StringSaver &Saver,
-                               SmallVectorImpl<const char *> &Opts) {
+                               SmallVectorImpl<StringRef> &Opts) {
   llvm::cl::TokenizeWindowsCommandLine(EnvValue, Saver, Opts);
   // The first instance of '#' should be replaced with '=' in each option.
-  for (const char *Opt : Opts)
-    if (char *NumberSignPtr = const_cast<char *>(::strchr(Opt, '#')))
-      *NumberSignPtr = '=';
+  for (StringRef Opt : Opts) {
+    auto Pos = Opt.find('#');
+    if (Pos != StringRef::npos)
+      const_cast<char *>(Opt.data())[Pos] = '=';
+  }
 }
 
 static void SetBackdoorDriverOutputsFromEnvVars(Driver &TheDriver) {
   // Handle CC_PRINT_OPTIONS and CC_PRINT_OPTIONS_FILE.
   TheDriver.CCPrintOptions = !!::getenv("CC_PRINT_OPTIONS");
   if (TheDriver.CCPrintOptions)
     TheDriver.CCPrintOptionsFilename = ::getenv("CC_PRINT_OPTIONS_FILE");
 
static void FixupDiagPrefixExeName(TextDiagnosticPrinter *DiagClient,
   StringRef ExeBasename(llvm::sys::path::filename(Path));
   if (ExeBasename.equals_lower("cl.exe"))
     ExeBasename = "clang-cl.exe";
   DiagClient->setPrefix(ExeBasename);
 }
 
 // This lets us create the DiagnosticsEngine with a properly-filled-out
 // DiagnosticOptions instance.
-static DiagnosticOptions *
-CreateAndPopulateDiagOpts(ArrayRef<const char *> argv) {
+static DiagnosticOptions *CreateAndPopulateDiagOpts(ArrayRef<StringRef> argv) {
   auto *DiagOpts = new DiagnosticOptions;
   std::unique_ptr<OptTable> Opts(createDriverOptTable());
   unsigned MissingArgIndex, MissingArgCount;
   InputArgList Args =
       Opts->ParseArgs(argv.slice(1), MissingArgIndex, MissingArgCount);
   // We ignore MissingArgCount and the return value of ParseDiagnosticArgs.
   // Any errors that would be diagnosed here will also be diagnosed later,
   // when the DiagnosticsEngine actually exists.
   (void)ParseDiagnosticArgs(*DiagOpts, Args);
   return DiagOpts;
 }
 
-static void SetInstallDir(SmallVectorImpl<const char *> &argv,
-                          Driver &TheDriver, bool CanonicalPrefixes) {
+static void SetInstallDir(SmallVectorImpl<StringRef> &argv, Driver &TheDriver,
+                          bool CanonicalPrefixes) {
   // Attempt to find the original path used to invoke the driver, to determine
   // the installed path. We do this manually, because we want to support that
   // path being a symlink.
   SmallString<128> InstalledPath(argv[0]);
 
   // Do a PATH lookup, if there are no directory components.
   if (llvm::sys::path::filename(InstalledPath) == InstalledPath)
     if (llvm::ErrorOr<std::string> Tmp = llvm::sys::findProgramByName(
             llvm::sys::path::filename(InstalledPath.str())))
       InstalledPath = *Tmp;
 
   // FIXME: We don't actually canonicalize this, we just make it absolute.
   if (CanonicalPrefixes)
     llvm::sys::fs::make_absolute(InstalledPath);
 
   StringRef InstalledPathParent(llvm::sys::path::parent_path(InstalledPath));
   if (llvm::sys::fs::exists(InstalledPathParent))
     TheDriver.setInstalledDir(InstalledPathParent);
 }
 
-static int ExecuteCC1Tool(ArrayRef<const char *> argv, StringRef Tool) {
+static int ExecuteCC1Tool(ArrayRef<StringRef> argv, StringRef Tool) {
   void *GetExecutablePathVP = (void *)(intptr_t) GetExecutablePath;
   if (Tool == "")
     return cc1_main(argv.slice(2), argv[0], GetExecutablePathVP);
   if (Tool == "as")
     return cc1as_main(argv.slice(2), argv[0], GetExecutablePathVP);
 
   // Reject unknown tools.
   llvm::errs() << "error: unknown integrated tool '" << Tool << "'\n";
   return 1;
 }
 
 int main(int argc_, const char **argv_) {
   llvm::sys::PrintStackTraceOnErrorSignal(argv_[0]);
   llvm::PrettyStackTraceProgram X(argc_, argv_);
   llvm::llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
   if (llvm::sys::Process::FixupStandardFileDescriptors())
     return 1;
 
-  SmallVector<const char *, 256> argv;
+  SmallVector<StringRef, 256> argv;
   llvm::SpecificBumpPtrAllocator<char> ArgAllocator;
   std::error_code EC = llvm::sys::Process::GetArgumentVector(
       argv, llvm::makeArrayRef(argv_, argc_), ArgAllocator);
   if (EC) {
     llvm::errs() << "error: couldn't get arguments: " << EC.message() << '\n';
     return 1;
   }
 
int main(int argc_, const char **argv_) {
   // are two ways to put clang in CL compatibility mode: argv[0] is either
   // clang-cl or cl, or --driver-mode=cl is on the command line. The normal
   // command line parsing can't happen until after response file parsing, so we
   // have to manually search for a --driver-mode=cl argument the hard way.
   // Finally, our -cc1 tools don't care which tokenization mode we use because
   // response files written by clang will tokenize the same way in either mode.
   bool ClangCLMode = false;
   if (TargetAndMode.second == "--driver-mode=cl" ||
-      std::find_if(argv.begin(), argv.end(), [](const char *F) {
-        return F && strcmp(F, "--driver-mode=cl") == 0;
+      std::find_if(argv.begin(), argv.end(), [](StringRef F) {
+        return F == "--driver-mode=cl";
       }) != argv.end()) {
     ClangCLMode = true;
   }
   enum { Default, POSIX, Windows } RSPQuoting = Default;
-  for (const char *F : argv) {
-    if (strcmp(F, "--rsp-quoting=posix") == 0)
+  for (StringRef F : argv) {
+    if (F == "--rsp-quoting=posix")
       RSPQuoting = POSIX;
-    else if (strcmp(F, "--rsp-quoting=windows") == 0)
+    else if (F == "--rsp-quoting=windows")
       RSPQuoting = Windows;
   }
 
   // Determines whether we want nullptr markers in argv to indicate response
   // files end-of-lines. We only use this for the /LINK driver argument with
   // clang-cl.exe on Windows.
   bool MarkEOLs = ClangCLMode;
 
   llvm::cl::TokenizerCallback Tokenizer;
   if (RSPQuoting == Windows || (RSPQuoting == Default && ClangCLMode))
     Tokenizer = &llvm::cl::TokenizeWindowsCommandLine;
   else
     Tokenizer = &llvm::cl::TokenizeGNUCommandLine;
 
   if (MarkEOLs && argv.size() > 1 && StringRef(argv[1]).startswith("-cc1"))
     MarkEOLs = false;
   llvm::cl::ExpandResponseFiles(Saver, Tokenizer, argv, MarkEOLs);
 
   // Handle -cc1 integrated tools, even if -cc1 was expanded from a response
   // file.
   auto FirstArg = std::find_if(argv.begin() + 1, argv.end(),
-                               [](const char *A) { return A != nullptr; });
+                               [](StringRef A) { return !A.empty(); });
   if (FirstArg != argv.end() && StringRef(*FirstArg).startswith("-cc1")) {
     // If -cc1 came from a response file, remove the EOL sentinels.
     if (MarkEOLs) {
-      auto newEnd = std::remove(argv.begin(), argv.end(), nullptr);
+      auto newEnd = std::remove(argv.begin(), argv.end(), StringRef());
       argv.resize(newEnd - argv.begin());
     }
-    return ExecuteCC1Tool(argv, argv[1] + 4);
+    return ExecuteCC1Tool(argv, argv[1].drop_front(4));
   }
 
   bool CanonicalPrefixes = true;
   for (int i = 1, size = argv.size(); i < size; ++i) {
     // Skip end-of-line response file markers
-    if (argv[i] == nullptr)
+    if (argv[i].empty())
       continue;
-    if (StringRef(argv[i]) == "-no-canonical-prefixes") {
+    if (argv[i] == "-no-canonical-prefixes") {
       CanonicalPrefixes = false;
       break;
     }
   }
 
   // Handle CL and _CL_ which permits additional command line options to be
   // prepended or appended.
   if (ClangCLMode) {
     // Arguments in "CL" are prepended.
     llvm::Optional<std::string> OptCL = llvm::sys::Process::GetEnv("CL");
     if (OptCL.hasValue()) {
-      SmallVector<const char *, 8> PrependedOpts;
+      SmallVector<StringRef, 8> PrependedOpts;
       getCLEnvVarOptions(OptCL.getValue(), Saver, PrependedOpts);
 
       // Insert right after the program name to prepend to the argument list.
       argv.insert(argv.begin() + 1, PrependedOpts.begin(), PrependedOpts.end());
     }
     // Arguments in "_CL_" are appended.
     llvm::Optional<std::string> Opt_CL_ = llvm::sys::Process::GetEnv("_CL_");
     if (Opt_CL_.hasValue()) {
-      SmallVector<const char *, 8> AppendedOpts;
+      SmallVector<StringRef, 8> AppendedOpts;
       getCLEnvVarOptions(Opt_CL_.getValue(), Saver, AppendedOpts);
 
       // Insert at the end of the argument list to append.
       argv.append(AppendedOpts.begin(), AppendedOpts.end());
     }
   }
 
   std::set<std::string> SavedStrings;

lld/COFF/Driver.h

 
 // Implemented in ICF.cpp.
 void doICF(const std::vector<Chunk *> &Chunks);
 
 class ArgParser {
 public:
   ArgParser() : Alloc(AllocAux) {}
   // Parses command line options.
-  llvm::opt::InputArgList parse(llvm::ArrayRef<const char *> Args);
+  llvm::opt::InputArgList parse(llvm::ArrayRef<StringRef> Args);
 
   // Concatenate LINK environment varirable and given arguments and parse them.
-  llvm::opt::InputArgList parseLINK(llvm::ArrayRef<const char *> Args);
+  llvm::opt::InputArgList parseLINK(llvm::ArrayRef<StringRef> Args);
 
   // Tokenizes a given string and then parses as command line options.
   llvm::opt::InputArgList parse(StringRef S) { return parse(tokenize(S)); }
 
 private:
-  std::vector<const char *> tokenize(StringRef S);
+  std::vector<StringRef> tokenize(StringRef S);
 
-  std::vector<const char *> replaceResponseFiles(std::vector<const char *>);
+  std::vector<StringRef> replaceResponseFiles(std::vector<StringRef>);
 
   llvm::BumpPtrAllocator AllocAux;
   llvm::StringSaver Alloc;
 };
 
 class LinkerDriver {
 public:
   LinkerDriver() : Alloc(AllocAux) {}
-  void link(llvm::ArrayRef<const char *> Args);
+  void link(llvm::ArrayRef<StringRef> Args);
 
   // Used by the resolver to parse .drectve section contents.
   void parseDirectives(StringRef S);
 
   std::unique_ptr<CpioFile> Cpio; // for /linkrepro
 
 private:
   llvm::BumpPtrAllocator AllocAux;
private:
   std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
 };
 
 void parseModuleDefs(MemoryBufferRef MB, llvm::StringSaver *Alloc);
 void writeImportLibrary();
 
 // Functions below this line are defined in DriverUtils.cpp.
 
-void printHelp(const char *Argv0);
+void printHelp(StringRef Argv0);
 
 // For /machine option.
 MachineTypes getMachineType(StringRef Arg);
 StringRef machineToStr(MachineTypes MT);
 
 // Parses a string in the form of "<integer>[,<integer>]".
 void parseNumbers(StringRef Arg, uint64_t *Addr, uint64_t *Size = nullptr);
 

lld/COFF/Driver.cpp

 using llvm::sys::fs::identify_magic;
 
 namespace lld {
 namespace coff {
 
 Configuration *Config;
 LinkerDriver *Driver;
 
-bool link(llvm::ArrayRef<const char *> Args) {
+bool link(llvm::ArrayRef<StringRef> Args) {
   Configuration C;
   LinkerDriver D;
   Config = &C;
   Driver = &D;
   Driver->link(Args);
   return true;
 }
 
static unsigned parseDebugType(StringRef Arg) {
   for (StringRef Type : Types)
     DebugTypes |= StringSwitch<unsigned>(Type.lower())
                       .Case("cv", static_cast<unsigned>(DebugType::CV))
                       .Case("pdata", static_cast<unsigned>(DebugType::PData))
                       .Case("fixup", static_cast<unsigned>(DebugType::Fixup));
   return DebugTypes;
 }
 
-void LinkerDriver::link(llvm::ArrayRef<const char *> ArgsArr) {
+void LinkerDriver::link(llvm::ArrayRef<StringRef> ArgsArr) {
   // If the first command line argument is "/lib", link.exe acts like lib.exe.
   // We call our own implementation of lib.exe that understands bitcode files.
   if (ArgsArr.size() > 1 && StringRef(ArgsArr[1]).equals_lower("/lib")) {
     if (llvm::libDriverMain(ArgsArr.slice(1)) != 0)
       fatal("lib failed");
     return;
   }
 

lld/COFF/DriverUtils.cpp

 };
 
 class COFFOptTable : public llvm::opt::OptTable {
 public:
   COFFOptTable() : OptTable(infoTable, true) {}
 };
 
 // Parses a given list of options.
-llvm::opt::InputArgList ArgParser::parse(ArrayRef<const char *> ArgsArr) {
+llvm::opt::InputArgList ArgParser::parse(ArrayRef<StringRef> ArgsArr) {
   // First, replace respnose files (@<file>-style options).
-  std::vector<const char *> Argv = replaceResponseFiles(ArgsArr);
+  std::vector<StringRef> Argv = replaceResponseFiles(ArgsArr);
 
   // Make InputArgList from string vectors.
   COFFOptTable Table;
   unsigned MissingIndex;
   unsigned MissingCount;
   llvm::opt::InputArgList Args =
       Table.ParseArgs(Argv, MissingIndex, MissingCount);
 
   // Print the real command line if response files are expanded.
   if (Args.hasArg(OPT_verbose) && ArgsArr.size() != Argv.size()) {
     llvm::outs() << "Command line:";
-    for (const char *S : Argv)
+    for (StringRef S : Argv)
       llvm::outs() << " " << S;
     llvm::outs() << "\n";
   }
 
   if (MissingCount)
     fatal("missing arg value for \"" + Twine(Args.getArgString(MissingIndex)) +
           "\", expected " + Twine(MissingCount) +
           (MissingCount == 1 ? " argument." : " arguments."));
   for (auto *Arg : Args.filtered(OPT_UNKNOWN))
     llvm::errs() << "ignoring unknown argument: " << Arg->getSpelling() << "\n";
   return Args;
 }
 
-llvm::opt::InputArgList ArgParser::parseLINK(ArrayRef<const char *> Args) {
+llvm::opt::InputArgList ArgParser::parseLINK(ArrayRef<StringRef> Args) {
   // Concatenate LINK env and given arguments and parse them.
   Optional<std::string> Env = Process::GetEnv("LINK");
   if (!Env)
     return parse(Args);
-  std::vector<const char *> V = tokenize(*Env);
+  std::vector<StringRef> V = tokenize(*Env);
   V.insert(V.end(), Args.begin(), Args.end());
   return parse(V);
 }
 
-std::vector<const char *> ArgParser::tokenize(StringRef S) {
-  SmallVector<const char *, 16> Tokens;
+std::vector<StringRef> ArgParser::tokenize(StringRef S) {
+  SmallVector<StringRef, 16> Tokens;
   StringSaver Saver(AllocAux);
   llvm::cl::TokenizeWindowsCommandLine(S, Saver, Tokens);
-  return std::vector<const char *>(Tokens.begin(), Tokens.end());
+  return std::vector<StringRef>(Tokens.begin(), Tokens.end());
 }
 
 // Creates a new command line by replacing options starting with '@'
 // character. '@<filename>' is replaced by the file's contents.
-std::vector<const char *>
-ArgParser::replaceResponseFiles(std::vector<const char *> Argv) {
-  SmallVector<const char *, 256> Tokens(Argv.data(), Argv.data() + Argv.size());
+std::vector<StringRef>
+ArgParser::replaceResponseFiles(std::vector<StringRef> Argv) {
+  SmallVector<StringRef, 256> Tokens(Argv.data(), Argv.data() + Argv.size());
   StringSaver Saver(AllocAux);
   ExpandResponseFiles(Saver, TokenizeWindowsCommandLine, Tokens);
-  return std::vector<const char *>(Tokens.begin(), Tokens.end());
+  return std::vector<StringRef>(Tokens.begin(), Tokens.end());
 }
 
-void printHelp(const char *Argv0) {
+void printHelp(StringRef Argv0) {
   COFFOptTable Table;
   Table.PrintHelp(llvm::outs(), Argv0, "LLVM Linker", false);
 }
 
 } // namespace coff
 } // namespace lld

lld/ELF/Driver.h

 
 namespace lld {
 namespace elf {
 
 extern class LinkerDriver *Driver;
 
 class LinkerDriver {
 public:
-  void main(ArrayRef<const char *> Args);
+  void main(ArrayRef<llvm::StringRef> Args);
   void addFile(StringRef Path, bool KnownScript = false);
   void addLibrary(StringRef Name);
   llvm::LLVMContext Context;      // to parse bitcode files
   std::unique_ptr<CpioFile> Cpio; // for reproduce
 
 private:
   std::vector<MemoryBufferRef> getArchiveMembers(MemoryBufferRef MB);
   llvm::Optional<MemoryBufferRef> readFile(StringRef Path);
private:
   std::vector<InputFile *> Files;
   std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
 };
 
 // Parses command line options.
 class ELFOptTable : public llvm::opt::OptTable {
 public:
   ELFOptTable();
-  llvm::opt::InputArgList parse(ArrayRef<const char *> Argv);
+  llvm::opt::InputArgList parse(ArrayRef<StringRef> Argv);
 
 private:
   llvm::BumpPtrAllocator Alloc;
 };
 
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,
 #define OPTION(_1, _2, ID, _4, _5, _6, _7, _8, _9, _10, _11) OPT_##ID,
 #include "Options.inc"
 #undef OPTION
 };
 
-void printHelp(const char *Argv0);
+void printHelp(StringRef Argv0);
 std::string getVersionString();
 std::vector<uint8_t> parseHexstring(StringRef S);
 
 std::string createResponseFile(const llvm::opt::InputArgList &Args);
 
 std::string findFromSearchPaths(StringRef Path);
 std::string searchLibrary(StringRef Path);
 std::string buildSysrootedPath(llvm::StringRef Dir, llvm::StringRef File);
 
 } // namespace elf
 } // namespace lld
 
 #endif

lld/ELF/Driver.cpp

 using namespace llvm::sys;
 
 using namespace lld;
 using namespace lld::elf;
 
 Configuration *elf::Config;
 LinkerDriver *elf::Driver;
 
-bool elf::link(ArrayRef<const char *> Args, raw_ostream &Error) {
+bool elf::link(ArrayRef<StringRef> Args, raw_ostream &Error) {
   HasError = false;
   ErrorOS = &Error;
 
   Configuration C;
   LinkerDriver D;
   ScriptConfiguration SC;
   Config = &C;
   Driver = &D;
static void initLLVM(opt::InputArgList &Args) {
 
   // This is a flag to discard all but GlobalValue names.
   // We want to enable it by default because it saves memory.
   // Disable it only when a developer option (-save-temps) is given.
   Driver->Context.setDiscardValueNames(!Config->SaveTemps);
   Driver->Context.enableDebugTypeODRUniquing();
 
   // Parse and evaluate -mllvm options.
-  std::vector<const char *> V;
+  std::vector<StringRef> V;
   V.push_back("lld (LLVM option parsing)");
   for (auto *Arg : Args.filtered(OPT_mllvm))
     V.push_back(Arg->getValue());
-  cl::ParseCommandLineOptions(V.size(), V.data());
+  cl::ParseCommandLineOptions(V.size(), V);
 }
 
 // Some command line options or some combinations of them are not allowed.
 // This function checks for such errors.
 static void checkOptions(opt::InputArgList &Args) {
   // The MIPS ABI as of 2016 does not support the GNU-style symbol lookup
   // table which is a relatively new feature.
   if (Config->EMachine == EM_MIPS && Config->GnuHash)
static int getInteger(opt::InputArgList &Args, unsigned Key, int Default) {
   if (auto *Arg = Args.getLastArg(Key)) {
     StringRef S = Arg->getValue();
     if (S.getAsInteger(10, V))
       error(Arg->getSpelling() + ": number expected, but got " + S);
   }
   return V;
 }
 
-static const char *getReproduceOption(opt::InputArgList &Args) {
+static StringRef getReproduceOption(opt::InputArgList &Args) {
   if (auto *Arg = Args.getLastArg(OPT_reproduce))
     return Arg->getValue();
-  return getenv("LLD_REPRODUCE");
+  return StringRef(getenv("LLD_REPRODUCE"));
 }
 
 static bool hasZOption(opt::InputArgList &Args, StringRef Key) {
   for (auto *Arg : Args.filtered(OPT_z))
     if (Key == Arg->getValue())
       return true;
   return false;
 }
if (Pos != StringRef::npos && Key == Value.substr(0, Pos)) {
       if (Value.getAsInteger(0, Result))
         error("invalid " + Key + ": " + Value);
       return Result;
     }
   }
   return Default;
 }
 
-void LinkerDriver::main(ArrayRef<const char *> ArgsArr) {
+void LinkerDriver::main(ArrayRef<StringRef> ArgsArr) {
   ELFOptTable Parser;
   opt::InputArgList Args = Parser.parse(ArgsArr.slice(1));
   if (Args.hasArg(OPT_help)) {
     printHelp(ArgsArr[0]);
     return;
   }
   if (Args.hasArg(OPT_version))
     outs() << getVersionString();
 
-  if (const char *Path = getReproduceOption(Args)) {
+  StringRef Path = getReproduceOption(Args);
+  if (!Path.empty()) {
     // Note that --reproduce is a debug option so you can ignore it
     // if you are trying to understand the whole picture of the code.
     ErrorOr<CpioFile *> F = CpioFile::create(Path);
     if (F) {
       Cpio.reset(*F);
       Cpio->append("response.txt", createResponseFile(Args));
       Cpio->append("version.txt", getVersionString());
     } else

lld/ELF/DriverUtils.cpp

if (auto *Arg = Args.getLastArg(OPT_rsp_quoting)) {
     return cl::TokenizeGNUCommandLine;
   }
   if (Triple(sys::getProcessTriple()).getOS() == Triple::Win32)
     return cl::TokenizeWindowsCommandLine;
   return cl::TokenizeGNUCommandLine;
 }
 
 // Parses a given list of options.
-opt::InputArgList ELFOptTable::parse(ArrayRef<const char *> Argv) {
+opt::InputArgList ELFOptTable::parse(ArrayRef<StringRef> Argv) {
   // Make InputArgList from string vectors.
   unsigned MissingIndex;
   unsigned MissingCount;
-  SmallVector<const char *, 256> Vec(Argv.data(), Argv.data() + Argv.size());
+  SmallVector<StringRef, 256> Vec(Argv.data(), Argv.data() + Argv.size());
 
   // We need to get the quoting style for response files before parsing all
   // options so we parse here before and ignore all the options but
   // --rsp-quoting.
   opt::InputArgList Args = this->ParseArgs(Vec, MissingIndex, MissingCount);
 
   // Expand response files. '@<filename>' is replaced by the file's contents.
   StringSaver Saver(Alloc);
   cl::ExpandResponseFiles(Saver, getQuotingStyle(Args), Vec);
 
   // Parse options and then do error checking.
   Args = this->ParseArgs(Vec, MissingIndex, MissingCount);
   if (MissingCount)
     error(Twine("missing arg value for \"") + Args.getArgString(MissingIndex) +
           "\", expected " + Twine(MissingCount) +
           (MissingCount == 1 ? " argument.\n" : " arguments"));
 
   for (auto *Arg : Args.filtered(OPT_UNKNOWN))
     error("unknown argument: " + Arg->getSpelling());
   return Args;
 }
 
-void elf::printHelp(const char *Argv0) {
+void elf::printHelp(StringRef Argv0) {
   ELFOptTable Table;
   Table.PrintHelp(outs(), Argv0, "lld", false);
 }
 
 std::string elf::getVersionString() {
   std::string Version = getLLDVersion();
   std::string Repo = getLLDRepositoryVersion();
   if (Repo.empty())

lld/include/lld/Core/LinkingContext.h

public:
   /// format the line as needed.
   bool logInputFiles() const { return _logInputFiles; }
 
   /// Parts of LLVM use global variables which are bound to command line
   /// options (see llvm::cl::Options). This method returns "command line"
   /// options which are used to configure LLVM's command line settings.
   /// For instance the -debug-only XXX option can be used to dynamically
   /// trace different parts of LLVM and lld.
-  const std::vector<const char *> &llvmOptions() const { return _llvmOptions; }
+  const std::vector<StringRef> &llvmOptions() const { return _llvmOptions; }
 
   /// \name Methods used by Drivers to configure TargetInfo
   /// @{
   void setOutputPath(StringRef str) { _outputPath = str; }
 
   // Set the entry symbol name. You may also need to call addDeadStripRoot() for
   // the symbol if your platform supports dead-stripping, so that the symbol
   // will not be removed from the output.
   void setEntrySymbolName(StringRef name) {
     _entrySymbolName = name;
   }
 
   void setDeadStripping(bool enable) { _deadStrip = enable; }
   void setGlobalsAreDeadStripRoots(bool v) { _globalsAreDeadStripRoots = v; }
   void setPrintRemainingUndefines(bool print) {
     _printRemainingUndefines = print;
   }
   void setAllowRemainingUndefines(bool allow) {
     _allowRemainingUndefines = allow;
   }
   void setAllowShlibUndefines(bool allow) { _allowShlibUndefines = allow; }
   void setLogInputFiles(bool log) { _logInputFiles = log; }
 
-  void appendLLVMOption(const char *opt) { _llvmOptions.push_back(opt); }
+  void appendLLVMOption(StringRef opt) { _llvmOptions.push_back(opt); }
 
   std::vector<std::unique_ptr<Node>> &getNodes() { return _nodes; }
   const std::vector<std::unique_ptr<Node>> &getNodes() const { return _nodes; }
 
   /// This method adds undefined symbols specified by the -u option to the to
   /// the list of undefined symbols known to the linker. This option essentially
   /// forces an undefined symbol to be created. You may also need to call
   /// addDeadStripRoot() for the symbol if your platform supports dead
protected:
   StringRef _entrySymbolName;
   bool _deadStrip = false;
   bool _globalsAreDeadStripRoots = false;
   bool _printRemainingUndefines = true;
   bool _allowRemainingUndefines = false;
   bool _logInputFiles = false;
   bool _allowShlibUndefines = false;
   std::vector<StringRef> _deadStripRoots;
-  std::vector<const char *> _llvmOptions;
+  std::vector<StringRef> _llvmOptions;
   StringRefVector _initialUndefinedSymbols;
   std::vector<std::unique_ptr<Node>> _nodes;
   mutable llvm::BumpPtrAllocator _allocator;
   mutable uint64_t _nextOrdinal = 0;
   Registry _registry;
 
 private:
   /// Validate the subclass bits. Only called by validate.
   virtual bool validateImpl(raw_ostream &diagnostics) = 0;
 };
 
 } // end namespace lld
 
 #endif

lld/include/lld/Driver/Driver.h

 //===- lld/Driver/Driver.h - Linker Driver Emulator -----------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_DRIVER_DRIVER_H
 #define LLD_DRIVER_DRIVER_H
 
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/Support/raw_ostream.h"
 
+namespace llvm {
+class StringRef;
+}
+
 namespace lld {
 namespace coff {
-bool link(llvm::ArrayRef<const char *> Args);
+bool link(llvm::ArrayRef<llvm::StringRef> Args);
 }
 
 namespace elf {
-bool link(llvm::ArrayRef<const char *> Args,
+bool link(llvm::ArrayRef<llvm::StringRef> Args,
           llvm::raw_ostream &Diag = llvm::errs());
 }
 
 namespace mach_o {
-bool link(llvm::ArrayRef<const char *> Args,
+bool link(llvm::ArrayRef<llvm::StringRef> Args,
           llvm::raw_ostream &Diag = llvm::errs());
 }
 }
 
 #endif

lld/lib/Driver/DarwinLdDriver.cpp

if (numStr.startswith_lower("0x"))
     numStr = numStr.drop_front(2);
   return numStr.getAsInteger(16, baseAddress);
 }
 
 static void parseLLVMOptions(const LinkingContext &ctx) {
   // Honor -mllvm
   if (!ctx.llvmOptions().empty()) {
     unsigned numArgs = ctx.llvmOptions().size();
-    auto **args = new const char *[numArgs + 2];
-    args[0] = "lld (LLVM option parsing)";
-    for (unsigned i = 0; i != numArgs; ++i)
-      args[i + 1] = ctx.llvmOptions()[i];
-    args[numArgs + 1] = nullptr;
-    llvm::cl::ParseCommandLineOptions(numArgs + 1, args);
+    SmallVector<StringRef, 20> LLVMArgs;
+    LLVMArgs.reserve(numArgs + 1);
+    LLVMArgs.push_back("lld (LLVM option parsing)");
+    LLVMArgs.append(ctx.llvmOptions().begin(), ctx.llvmOptions().end());
+    llvm::cl::ParseCommandLineOptions(numArgs + 1, LLVMArgs);
   }
 }
 
 namespace lld {
 namespace mach_o {
 
-bool parse(llvm::ArrayRef<const char *> args, MachOLinkingContext &ctx,
+bool parse(llvm::ArrayRef<StringRef> args, MachOLinkingContext &ctx,
            raw_ostream &diagnostics) {
   // Parse command line options using DarwinLdOptions.td
   DarwinLdOptTable table;
   unsigned missingIndex;
   unsigned missingCount;
+
+  SmallVector<StringRef, 32> Args;
+  Args.reserve(args.size());
+  for (auto Arg : args.slice(1))
+    Args.push_back(StringRef(Arg));
+
   llvm::opt::InputArgList parsedArgs =
-      table.ParseArgs(args.slice(1), missingIndex, missingCount);
+      table.ParseArgs(Args, missingIndex, missingCount);
   if (missingCount) {
     diagnostics << "error: missing arg value for '"
                 << parsedArgs.getArgString(missingIndex) << "' expected "
                 << missingCount << " argument(s).\n";
     return false;
   }
 
   for (auto unknownArg : parsedArgs.filtered(OPT_UNKNOWN)) {
bool parse(llvm::ArrayRef<StringRef> args, MachOLinkingContext &ctx,
   }
 
   // Handle -bundle_loader
   if (llvm::opt::Arg *loader = parsedArgs.getLastArg(OPT_bundle_loader))
     ctx.setBundleLoader(loader->getValue());
 
   // Handle -sectalign segname sectname align
   for (auto &alignArg : parsedArgs.filtered(OPT_sectalign)) {
-    const char* segName   = alignArg->getValue(0);
-    const char* sectName  = alignArg->getValue(1);
-    const char* alignStr  = alignArg->getValue(2);
+    StringRef segName = alignArg->getValue(0);
+    StringRef sectName = alignArg->getValue(1);
+    StringRef alignStr = alignArg->getValue(2);
     if ((alignStr[0] == '0') && (alignStr[1] == 'x'))
-      alignStr += 2;
+      alignStr = alignStr.drop_front(2);
     unsigned long long alignValue;
     if (llvm::getAsUnsignedInteger(alignStr, 16, alignValue)) {
       diagnostics << "error: -sectalign alignment value '"
                   << alignStr << "' not a valid number\n";
       return false;
     }
     uint16_t align = 1 << llvm::countTrailingZeros(alignValue);
     if (!llvm::isPowerOf2_64(alignValue)) {
case OPT_filelist:
           diagnostics << "error: ";
           EI.log(diagnostics);
           diagnostics << ", processing '-filelist " << arg->getValue() << "'\n";
         });
         return false;
       }
       break;
     case OPT_sectcreate: {
-        const char* seg  = arg->getValue(0);
-        const char* sect = arg->getValue(1);
-        const char* fileName = arg->getValue(2);
+      StringRef seg = arg->getValue(0);
+      StringRef sect = arg->getValue(1);
+      StringRef fileName = arg->getValue(2);
 
-        ErrorOr<std::unique_ptr<MemoryBuffer>> contentOrErr =
           MemoryBuffer::getFile(fileName);
 
-        if (!contentOrErr) {
-          diagnostics << "error: can't open -sectcreate file " << fileName << "\n";
-          return false;
+        diagnostics << "error: can't open -sectcreate file " << fileName
+                    << "\n";
         }
 
         ctx.addSectCreateSection(seg, sect, std::move(*contentOrErr));
       }
       break;
     }
   }
 
else
     ctx.createInternalFiles(Files);
   for (auto i = Files.rbegin(), e = Files.rend(); i != e; ++i) {
     auto &members = ctx.getNodes();
     members.insert(members.begin(), llvm::make_unique<FileNode>(std::move(*i)));
   }
 }
 
 /// This is where the link is actually performed.
-bool link(llvm::ArrayRef<const char *> args, raw_ostream &diagnostics) {
+bool link(llvm::ArrayRef<StringRef> args, raw_ostream &diagnostics) {
   MachOLinkingContext ctx;
   if (!parse(args, ctx, diagnostics))
     return false;
   if (ctx.doNothing())
     return true;
   if (ctx.getNodes().empty())
     return false;
 

lld/tools/lld/lld.cpp

#endif
   SmallVector<StringRef, 3> V;
   Progname.split(V, "-");
   for (StringRef S : V)
     if (Flavor F = getFlavor(S))
       return F;
   return Invalid;
 }
 
-static Flavor parseFlavor(std::vector<const char *> &V) {
+static Flavor parseFlavor(std::vector<StringRef> &V) {
   // Parse -flavor option.
-  if (V.size() > 1 && V[1] == StringRef("-flavor")) {
+  if (V.size() > 1 && V[1] == "-flavor") {
     if (V.size() <= 2)
       die("missing arg value for '-flavor'");
     Flavor F = getFlavor(V[2]);
     if (F == Invalid)
-      die("Unknown flavor: " + StringRef(V[2]));
+      die("Unknown flavor: " + V[2]);
     V.erase(V.begin() + 1, V.begin() + 3);
     return F;
   }
 
   // Deduct the flavor from argv[0].
   StringRef Arg0 = path::filename(V[0]);
   if (Arg0.endswith_lower(".exe"))
     Arg0 = Arg0.drop_back(4);
   return parseProgname(Arg0);
 }
 
 /// Universal linker main(). This linker emulates the gnu, darwin, or
 /// windows linker based on the argv[0] or -flavor option.
 int main(int Argc, const char **Argv) {
   // Standard set up, so program fails gracefully.
   sys::PrintStackTraceOnErrorSignal(Argv[0]);
   PrettyStackTraceProgram StackPrinter(Argc, Argv);
   llvm_shutdown_obj Shutdown;
 
-  std::vector<const char *> Args(Argv, Argv + Argc);
+  std::vector<StringRef> Args;
+  Args.reserve(Argc);
+  for (int ArgId = 0; ArgId < Argc; ++ArgId)
+    Args.push_back(StringRef(Argv[ArgId]));
   switch (parseFlavor(Args)) {
   case Gnu:
     return !elf::link(Args);
   case WinLink:
     return !coff::link(Args);
   case Darwin:
     return !mach_o::link(Args);
   default:
     die("lld is a generic driver.\n"
         "Invoke ld.lld (Unix), ld (Mac) or lld-link (Windows) instead.");
   }
 }

lld/unittests/DriverTests/DarwinLdDriverTest.cpp

 #include "llvm/Support/raw_ostream.h"
 #include "gtest/gtest.h"
 
 using namespace llvm;
 using namespace lld;
 
 namespace lld {
 namespace mach_o {
-bool parse(llvm::ArrayRef<const char *> args, MachOLinkingContext &ctx,
+bool parse(llvm::ArrayRef<StringRef> args, MachOLinkingContext &ctx,
            raw_ostream &diagnostics);
 }
 }
 
 namespace {
 class DarwinLdParserTest : public testing::Test {
 protected:
   int inputFileCount() { return _ctx.getNodes().size(); }
 
   std::string inputFile(int index) {
     Node &node = *_ctx.getNodes()[index];
     if (node.kind() == Node::Kind::File)
       return cast<FileNode>(&node)->getFile()->path();
     llvm_unreachable("not handling other types of input files");
   }
 
-  bool parse(std::vector<const char *> args) {
+  bool parse(std::vector<StringRef> args) {
     args.insert(args.begin(), "ld");
     std::string errorMessage;
     raw_string_ostream os(errorMessage);
     return mach_o::parse(args, _ctx, os);
   }
 
   MachOLinkingContext _ctx;
 };

llvm/include/llvm/LibDriver/LibDriver.h

 // bitcode files. Used by llvm-lib and lld-link /lib.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_LIBDRIVER_LIBDRIVER_H
 #define LLVM_LIBDRIVER_LIBDRIVER_H
 
 namespace llvm {
+class StringRef;
 template <typename T> class ArrayRef;
 
-int libDriverMain(ArrayRef<const char *> ARgs);
+int libDriverMain(ArrayRef<StringRef> ARgs);
 }
 
 #endif

llvm/include/llvm/Option/Arg.h

private:
   ///
   /// This is used for generating "argument unused" diagnostics.
   mutable unsigned Claimed : 1;
 
   /// \brief Does this argument own its values?
   mutable unsigned OwnsValues : 1;
 
   /// \brief The argument values, as C strings.
-  SmallVector<const char *, 2> Values;
+  SmallVector<StringRef, 2> Values;
 
 public:
   Arg(const Option Opt, StringRef Spelling, unsigned Index,
       const Arg *BaseArg = nullptr);
-  Arg(const Option Opt, StringRef Spelling, unsigned Index,
-      const char *Value0, const Arg *BaseArg = nullptr);
-  Arg(const Option Opt, StringRef Spelling, unsigned Index,
-      const char *Value0, const char *Value1, const Arg *BaseArg = nullptr);
+  Arg(const Option Opt, StringRef Spelling, unsigned Index, StringRef Value0,
+      const Arg *BaseArg = nullptr);
+  Arg(const Option Opt, StringRef Spelling, unsigned Index, StringRef Value0,
+      StringRef Value1, const Arg *BaseArg = nullptr);
   ~Arg();
 
   const Option &getOption() const { return Opt; }
   StringRef getSpelling() const { return Spelling; }
   unsigned getIndex() const { return Index; }
 
   /// \brief 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;
   }
   void setBaseArg(const Arg *BaseArg) { this->BaseArg = BaseArg; }
 
   bool getOwnsValues() const { return OwnsValues; }
   void setOwnsValues(bool Value) const { OwnsValues = Value; }
 
   bool isClaimed() const { return getBaseArg().Claimed; }
 
   /// \brief Set the Arg claimed bit.
   void claim() const { getBaseArg().Claimed = true; }
 
   unsigned getNumValues() const { return Values.size(); }
-  const char *getValue(unsigned N = 0) const {
-    return Values[N];
-  }
+  StringRef getValue(unsigned N = 0) const { return Values[N]; }
 
-  SmallVectorImpl<const char *> &getValues() { return Values; }
-  const SmallVectorImpl<const char *> &getValues() const { return Values; }
+  SmallVectorImpl<StringRef> &getValues() { return Values; }
+  const SmallVectorImpl<StringRef> &getValues() const { return Values; }
 
   bool containsValue(StringRef Value) const {
     for (unsigned i = 0, e = getNumValues(); i != e; ++i)
       if (Values[i] == Value)
         return true;
     return false;
   }
 

llvm/include/llvm/Option/ArgList.h

public:
   Arg *getLastArg(OptSpecifier Id0, OptSpecifier Id1, OptSpecifier Id2,
                   OptSpecifier Id3, OptSpecifier Id4, OptSpecifier Id5,
                   OptSpecifier Id6) const;
   Arg *getLastArg(OptSpecifier Id0, OptSpecifier Id1, OptSpecifier Id2,
                   OptSpecifier Id3, OptSpecifier Id4, OptSpecifier Id5,
                   OptSpecifier Id6, OptSpecifier Id7) const;
 
   /// getArgString - Return the input argument string at \p Index.
-  virtual const char *getArgString(unsigned Index) const = 0;
+  virtual StringRef getArgString(unsigned Index) const = 0;
 
   /// getNumInputArgStrings - Return the number of original argument strings,
   /// which are guaranteed to be the first strings in the argument string
   /// list.
   virtual unsigned getNumInputArgStrings() const = 0;
 
   /// @}
   /// @name Argument Lookup Utilities
public:
   void ClaimAllArgs() const;
 
   /// @}
   /// @name Arg Synthesis
   /// @{
 
   /// Construct a constant string pointer whose
   /// lifetime will match that of the ArgList.
-  virtual const char *MakeArgStringRef(StringRef Str) const = 0;
-  const char *MakeArgString(const Twine &Str) const {
+  virtual StringRef MakeArgStringRef(StringRef Str) const = 0;
+  StringRef MakeArgString(const Twine &Str) const {
     SmallString<256> Buf;
-    return MakeArgStringRef(Str.toStringRef(Buf));
+    return StringRef(MakeArgStringRef(Str.toStringRef(Buf)));
   }
 
   /// \brief Create an arg string for (\p LHS + \p RHS), reusing the
   /// string at \p Index if possible.
-  const char *GetOrMakeJoinedArgString(unsigned Index, StringRef LHS,
-                                        StringRef RHS) const;
+  StringRef GetOrMakeJoinedArgString(unsigned Index, StringRef LHS,
 
   void print(raw_ostream &O) const;
   void dump() const;
 
   /// @}
 };
 
 class InputArgList final : public ArgList {
private:
 
   /// The number of original input argument strings.
   unsigned NumInputArgStrings;
 
   /// Release allocated arguments.
   void releaseMemory();
 
 public:
+  InputArgList(ArrayRef<StringRef> Args);
   InputArgList(const char* const *ArgBegin, const char* const *ArgEnd);
   InputArgList(InputArgList &&RHS)
       : ArgList(std::move(RHS)), ArgStrings(std::move(RHS.ArgStrings)),
         SynthesizedStrings(std::move(RHS.SynthesizedStrings)),
         NumInputArgStrings(RHS.NumInputArgStrings) {}
   InputArgList &operator=(InputArgList &&RHS) {
     releaseMemory();
     ArgList::operator=(std::move(RHS));
     ArgStrings = std::move(RHS.ArgStrings);
     SynthesizedStrings = std::move(RHS.SynthesizedStrings);
     NumInputArgStrings = RHS.NumInputArgStrings;
     return *this;
   }
   ~InputArgList() { releaseMemory(); }
 
-  const char *getArgString(unsigned Index) const override {
-    return ArgStrings[Index];
+  StringRef getArgString(unsigned Index) const override {
+    return StringRef(ArgStrings[Index]);
   }
 
   unsigned getNumInputArgStrings() const override {
     return NumInputArgStrings;
   }
 
   /// @name Arg Synthesis
   /// @{
 
 public:
   /// MakeIndex - Get an index for the given string(s).
   unsigned MakeIndex(StringRef String0) const;
   unsigned MakeIndex(StringRef String0, StringRef String1) const;
 
   using ArgList::MakeArgString;
-  const char *MakeArgStringRef(StringRef Str) const override;
+  StringRef MakeArgStringRef(StringRef Str) const override;
 
   /// @}
 };
 
 /// DerivedArgList - An ordered collection of driver arguments,
 /// whose storage may be in another argument list.
 class DerivedArgList final : public ArgList {
   const InputArgList &BaseArgs;
 
   /// The list of arguments we synthesized.
   mutable SmallVector<std::unique_ptr<Arg>, 16> SynthesizedArgs;
 
 public:
   /// Construct a new derived arg list from \p BaseArgs.
   DerivedArgList(const InputArgList &BaseArgs);
 
-  const char *getArgString(unsigned Index) const override {
+  StringRef getArgString(unsigned Index) const override {
     return BaseArgs.getArgString(Index);
   }
 
   unsigned getNumInputArgStrings() const override {
     return BaseArgs.getNumInputArgStrings();
   }
 
   const InputArgList &getBaseArgs() const {
     return BaseArgs;
   }
 
   /// @name Arg Synthesis
   /// @{
 
   /// AddSynthesizedArg - Add a argument to the list of synthesized arguments
   /// (to be freed).
   void AddSynthesizedArg(Arg *A);
 
   using ArgList::MakeArgString;
-  const char *MakeArgStringRef(StringRef Str) const override;
+  StringRef MakeArgStringRef(StringRef Str) const override;
 
   /// AddFlagArg - Construct a new FlagArg for the given option \p Id and
   /// append it to the argument list.
   void AddFlagArg(const Arg *BaseArg, const Option Opt) {
     append(MakeFlagArg(BaseArg, Opt));
   }
 
   /// AddPositionalArg - Construct a new Positional arg for the given option

llvm/include/llvm/Option/OptTable.h

public:
 
   /// \brief 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;
 
   /// \brief Lookup the name of the given option.
-  const char *getOptionName(OptSpecifier id) const {
-    return getInfo(id).Name;
-  }
+  StringRef getOptionName(OptSpecifier id) const { return getInfo(id).Name; }
 
   /// \brief Get the kind of the given option.
   unsigned getOptionKind(OptSpecifier id) const {
     return getInfo(id).Kind;
   }
 
   /// \brief Get the group id for the given option.
   unsigned getOptionGroupID(OptSpecifier id) const {
public:
   /// not be parsed.
   /// \param MissingArgCount - On error, the number of missing options.
   /// \param FlagsToInclude - Only parse options with any of these flags.
   /// Zero is the default which includes all flags.
   /// \param FlagsToExclude - Don't parse options with this flag.  Zero
   /// is the default and means exclude nothing.
   /// \return An InputArgList; on error this will contain all the options
   /// which could be parsed.
-  InputArgList ParseArgs(ArrayRef<const char *> Args, unsigned &MissingArgIndex,
+  InputArgList ParseArgs(ArrayRef<StringRef> Args, unsigned &MissingArgIndex,
                          unsigned &MissingArgCount, unsigned FlagsToInclude = 0,
                          unsigned FlagsToExclude = 0) const;
 
   /// \brief Render the help text for an option table.
   ///
   /// \param OS - The stream to write the help text to.
   /// \param Name - The name to use in the usage line.
   /// \param Title - The title to use in the usage line.
   /// \param FlagsToInclude - If non-zero, only include options with any
   ///                         of these flags set.
   /// \param FlagsToExclude - Exclude options with any of these flags set.
-  void PrintHelp(raw_ostream &OS, const char *Name,
-                 const char *Title, unsigned FlagsToInclude,
+  void PrintHelp(raw_ostream &OS, StringRef Name,
+                 StringRef Title, unsigned FlagsToInclude,
                  unsigned FlagsToExclude) const;
 
-  void PrintHelp(raw_ostream &OS, const char *Name,
-                  const char *Title, bool ShowHidden = false) const;
+  void PrintHelp(raw_ostream &OS, StringRef Name,
+                  StringRef Title, bool ShowHidden = false) const;
 };
 } // end namespace opt
 } // end namespace llvm
 
 #endif

llvm/include/llvm/Option/Option.h

 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/ErrorHandling.h"
 
 namespace llvm {
 namespace opt {
 class Arg;
 class ArgList;
 /// ArgStringList - Type used for constructing argv lists for subprocesses.
-typedef SmallVector<const char*, 16> ArgStringList;
+typedef SmallVector<StringRef, 16> ArgStringList;
 
 /// Base flags for all options. Custom flags may be added after.
 enum DriverFlag {
   HelpHidden       = (1 << 0),
   RenderAsInput    = (1 << 1),
   RenderJoined     = (1 << 2),
   RenderSeparate   = (1 << 3)
 };
assert((!Info->AliasArgs || Info->AliasArgs[0] != 0) &&
            "AliasArgs should be either 0 or non-empty.");
 
     return Info->AliasArgs;
   }
 
   /// \brief Get the default prefix for this option.
   StringRef getPrefix() const {
     const char *Prefix = *Info->Prefixes;
-    return Prefix ? Prefix : StringRef();
+    return Prefix ? StringRef(Prefix) : StringRef();
   }
 
   /// \brief Get the name of this option with the default prefix.
   std::string getPrefixedName() const {
     std::string Ret = getPrefix();
     Ret += getName();
     return Ret;
   }

llvm/include/llvm/Support/CommandLine.h

 namespace cl {
 
 //===----------------------------------------------------------------------===//
 // ParseCommandLineOptions - Command line option processing entry point.
 //
 bool ParseCommandLineOptions(int argc, const char *const *argv,
                              StringRef Overview = "",
                              bool IgnoreErrors = false);
+bool ParseCommandLineOptions(int argc, ArrayRef<StringRef> argv,
+                             StringRef Overview = "",
+                             bool IgnoreErrors = false);
 
 //===----------------------------------------------------------------------===//
 // ParseEnvironmentOptions - Environment variable option processing alternate
 //                           entry point.
 //
 void ParseEnvironmentOptions(const char *progName, const char *envvar,
                              const char *Overview = "");
 

 /// a special character to make it possible to accept most Windows file paths.
 ///
 /// \param [in] Source The string to be split on whitespace with quotes.
 /// \param [in] Saver Delegates back to the caller for saving parsed strings.
 /// \param [in] MarkEOLs true if tokenizing a response file and you want end of
 /// lines and end of the response file to be marked with a nullptr string.
 /// \param [out] NewArgv All parsed strings are appended to NewArgv.
 void TokenizeGNUCommandLine(StringRef Source, StringSaver &Saver,
-                            SmallVectorImpl<const char *> &NewArgv,
+                            SmallVectorImpl<StringRef> &NewArgv,
                             bool MarkEOLs = false);
 
 /// \brief Tokenizes a Windows command line which may contain quotes and escaped
 /// quotes.
 ///
 /// See MSDN docs for CommandLineToArgvW for information on the quoting rules.
 /// http://msdn.microsoft.com/en-us/library/windows/desktop/17w5ykft(v=vs.85).aspx
 ///
 /// \param [in] Source The string to be split on whitespace with quotes.
 /// \param [in] Saver Delegates back to the caller for saving parsed strings.
 /// \param [in] MarkEOLs true if tokenizing a response file and you want end of
 /// lines and end of the response file to be marked with a nullptr string.
 /// \param [out] NewArgv All parsed strings are appended to NewArgv.
 void TokenizeWindowsCommandLine(StringRef Source, StringSaver &Saver,
-                                SmallVectorImpl<const char *> &NewArgv,
+                                SmallVectorImpl<StringRef> &NewArgv,
                                 bool MarkEOLs = false);
 
 /// \brief String tokenization function type.  Should be compatible with either
 /// Windows or Unix command line tokenizers.
 typedef void (*TokenizerCallback)(StringRef Source, StringSaver &Saver,
-                                  SmallVectorImpl<const char *> &NewArgv,
+                                  SmallVectorImpl<StringRef> &NewArgv,
                                   bool MarkEOLs);
 
 /// \brief Expand response files on a command line recursively using the given
 /// StringSaver and tokenization strategy.  Argv should contain the command line
 /// before expansion and will be modified in place. If requested, Argv will
 /// also be populated with nullptrs indicating where each response file line
 /// ends, which is useful for the "/link" argument that needs to consume all
 /// remaining arguments only until the next end of line, when in a response
 /// file.
 ///
 /// \param [in] Saver Delegates back to the caller for saving parsed strings.
 /// \param [in] Tokenizer Tokenization strategy. Typically Unix or Windows.
 /// \param [in,out] Argv Command line into which to expand response files.
 /// \param [in] MarkEOLs Mark end of lines and the end of the response file
 /// with nullptrs in the Argv vector.
 /// \return true if all @files were expanded successfully or there were none.
 bool ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
-                         SmallVectorImpl<const char *> &Argv,
+                         SmallVectorImpl<StringRef> &Argv,
                          bool MarkEOLs = false);
 
 /// \brief Mark all options not part of this category as cl::ReallyHidden.
 ///
 /// \param Category the category of options to keep displaying
 ///
 /// Some tools (like clang-format) like to be able to hide all options that are
 /// not specific to the tool. This function allows a tool to specify a single

llvm/include/llvm/Support/Process.h

public:
   /// variable.
   static Optional<std::string> FindInEnvPath(const std::string& EnvName,
                                              const std::string& FileName);
 
   /// This function returns a SmallVector containing the arguments passed from
   /// the operating system to the program.  This function expects to be handed
   /// the vector passed in from main.
   static std::error_code
-  GetArgumentVector(SmallVectorImpl<const char *> &Args,
+  GetArgumentVector(SmallVectorImpl<StringRef> &Args,
                     ArrayRef<const char *> ArgsFromMain,
                     SpecificBumpPtrAllocator<char> &ArgAllocator);
 
   // This functions ensures that the standard file descriptors (input, output,
   // and error) are properly mapped to a file descriptor before we use any of
   // them.  This should only be called by standalone programs, library
   // components should not call this.
   static std::error_code FixupStandardFileDescriptors();

llvm/include/llvm/Support/Program.h

#endif
   /// ProcessInfo.ProcessHandle to avoid memory leaks.
   ProcessInfo
   ExecuteNoWait(StringRef Program, const char **args, const char **env = nullptr,
                 const StringRef **redirects = nullptr, unsigned memoryLimit = 0,
                 std::string *ErrMsg = nullptr, bool *ExecutionFailed = nullptr);
 
   /// Return true if the given arguments fit within system-specific
   /// argument length limits.
-  bool commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef<const char*> Args);
+  bool commandLineFitsWithinSystemLimits(StringRef Program,
+                                         ArrayRef<StringRef> Args);
 
   /// File encoding options when writing contents that a non-UTF8 tool will
   /// read (on Windows systems). For UNIX, we always use UTF-8.
   enum WindowsEncodingMethod {
     /// UTF-8 is the LLVM native encoding, being the same as "do not perform
     /// encoding conversion".
     WEM_UTF8,
     WEM_CurrentCodePage,

llvm/lib/LibDriver/LibDriver.cpp

for (auto Dir : Paths) {
     SmallString<128> Path = Dir;
     sys::path::append(Path, File);
     if (sys::fs::exists(Path))
       return Path.str().str();
   }
   return Optional<std::string>();
 }
 
-int llvm::libDriverMain(llvm::ArrayRef<const char*> ArgsArr) {
-  SmallVector<const char *, 20> NewArgs(ArgsArr.begin(), ArgsArr.end());
+int llvm::libDriverMain(llvm::ArrayRef<StringRef> ArgsArr) {
+  SmallVector<StringRef, 20> NewArgs(ArgsArr.begin(), ArgsArr.end());
   BumpPtrAllocator Alloc;
   StringSaver Saver(Alloc);
   cl::ExpandResponseFiles(Saver, cl::TokenizeWindowsCommandLine, NewArgs);
   ArgsArr = NewArgs;
 
   LibOptTable Table;
   unsigned MissingIndex;
   unsigned MissingCount;
+  SmallVector<StringRef, 20> ArgsStr;
+  for (auto Arg : ArgsArr.slice(1))
+    ArgsStr.push_back(Arg);
+
   llvm::opt::InputArgList Args =
-      Table.ParseArgs(ArgsArr.slice(1), MissingIndex, MissingCount);
+      Table.ParseArgs(ArgsStr, MissingIndex, MissingCount);
   if (MissingCount) {
     llvm::errs() << "missing arg value for \""
                  << Args.getArgString(MissingIndex) << "\", expected "
                  << MissingCount
                  << (MissingCount == 1 ? " argument.\n" : " arguments.\n");
     return 1;
   }
   for (auto *Arg : Args.filtered(OPT_UNKNOWN))

llvm/lib/Option/Arg.cpp

 
 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) {}
 
-Arg::Arg(const Option Opt, StringRef S, unsigned Index, const char *Value0,
+Arg::Arg(const Option Opt, StringRef S, unsigned Index, StringRef Value0,
          const Arg *BaseArg)
     : Opt(Opt), BaseArg(BaseArg), Spelling(S), Index(Index), Claimed(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)
+Arg::Arg(const Option Opt, StringRef S, unsigned Index, StringRef Value0,
+         StringRef Value1, const Arg *BaseArg)
     : Opt(Opt), BaseArg(BaseArg), Spelling(S), Index(Index), Claimed(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];
+      delete[] Values[i].data();
   }
 }
 
 void Arg::print(raw_ostream& O) const {
   O << "<";
 
   O << " Opt:";
   Opt.print(O);
std::string Arg::getAsString(const ArgList &Args) const {
   return OS.str();
 }
 
 void Arg::renderAsInput(const ArgList &Args, ArgStringList &Output) const {
   if (!getOption().hasNoOptAsInput()) {
     render(Args, Output);
     return;
   }
-
-  Output.append(Values.begin(), Values.end());
+  for (auto Val : Values)
+    Output.push_back(Val);
 }
 
 void Arg::render(const ArgList &Args, ArgStringList &Output) const {
   switch (getOption().getRenderStyle()) {
   case Option::RenderValuesStyle:
-    Output.append(Values.begin(), Values.end());
+    for (auto Val : Values)
+      Output.push_back(Val);
     break;
 
   case Option::RenderCommaJoinedStyle: {
     SmallString<256> Res;
     llvm::raw_svector_ostream OS(Res);
     OS << getSpelling();
     for (unsigned i = 0, e = getNumValues(); i != e; ++i) {
       if (i) OS << ',';

llvm/lib/Option/ArgList.cpp

 StringRef ArgList::getLastArgValue(OptSpecifier Id,
                                          StringRef Default) const {
   if (Arg *A = getLastArg(Id))
     return A->getValue();
   return Default;
 }
 
 std::vector<std::string> ArgList::getAllArgValues(OptSpecifier Id) const {
-  SmallVector<const char *, 16> Values;
+  SmallVector<StringRef, 16> Values;
   AddAllArgValues(Values, Id);
   return std::vector<std::string>(Values.begin(), Values.end());
 }
 
 void ArgList::AddLastArg(ArgStringList &Output, OptSpecifier Id) const {
   if (Arg *A = getLastArg(Id)) {
     A->claim();
     A->render(*this, Output);
for (auto Arg: filtered(Id0, Id1, Id2)) {
     Arg->render(*this, Output);
   }
 }
 
 void ArgList::AddAllArgValues(ArgStringList &Output, OptSpecifier Id0,
                               OptSpecifier Id1, OptSpecifier Id2) const {
   for (auto Arg : filtered(Id0, Id1, Id2)) {
     Arg->claim();
-    const auto &Values = Arg->getValues();
-    Output.append(Values.begin(), Values.end());
+    for (auto &Value : Arg->getValues())
+      Output.push_back(Value);
   }
 }
 
 void ArgList::AddAllArgsTranslated(ArgStringList &Output, OptSpecifier Id0,
                                    const char *Translation,
                                    bool Joined) const {
   for (auto Arg: filtered(Id0)) {
     Arg->claim();
 
     if (Joined) {
-      Output.push_back(MakeArgString(StringRef(Translation) +
-                                     Arg->getValue(0)));
+      Output.push_back(
+          MakeArgString(StringRef(Translation) + Arg->getValue(0)));
     } else {
       Output.push_back(Translation);
       Output.push_back(Arg->getValue(0));
     }
   }
 }
 
 void ArgList::ClaimAllArgs(OptSpecifier Id0) const {
   for (auto Arg : filtered(Id0))
     Arg->claim();
 }
 
 void ArgList::ClaimAllArgs() const {
   for (const_iterator it = begin(), ie = end(); it != ie; ++it)
     if (!(*it)->isClaimed())
       (*it)->claim();
 }
 
-const char *ArgList::GetOrMakeJoinedArgString(unsigned Index,
-                                              StringRef LHS,
-                                              StringRef RHS) const {
-  StringRef Cur = getArgString(Index);
+StringRef ArgList::GetOrMakeJoinedArgString(unsigned Index, StringRef LHS,
+  StringRef Cur(getArgString(Index));
   if (Cur.size() == LHS.size() + RHS.size() &&
       Cur.startswith(LHS) && Cur.endswith(RHS))
     return Cur.data();
 
   return MakeArgString(LHS + RHS);
 }
 
 void ArgList::print(raw_ostream &O) const {
   for (Arg *A : *this) {
     O << "* ";
     A->print(O);
   }
 }
 
 LLVM_DUMP_METHOD void ArgList::dump() const { print(dbgs()); }
 
 //
 
 void InputArgList::releaseMemory() {
   // An InputArgList always owns its arguments.
   for (Arg *A : *this)
     delete A;
 }
 
+InputArgList::InputArgList(ArrayRef<StringRef> Args)
+    : NumInputArgStrings(Args.size()) {
+  ArgStrings.append(Args.begin(), Args.end());
+}
+
 InputArgList::InputArgList(const char* const *ArgBegin,
                            const char* const *ArgEnd)
   : NumInputArgStrings(ArgEnd - ArgBegin) {
   ArgStrings.append(ArgBegin, ArgEnd);
 }
 
 unsigned InputArgList::MakeIndex(StringRef String0) const {
   unsigned Index = ArgStrings.size();
unsigned InputArgList::MakeIndex(StringRef String0,
                                  StringRef String1) const {
   unsigned Index0 = MakeIndex(String0);
   unsigned Index1 = MakeIndex(String1);
   assert(Index0 + 1 == Index1 && "Unexpected non-consecutive indices!");
   (void) Index1;
   return Index0;
 }
 
-const char *InputArgList::MakeArgStringRef(StringRef Str) const {
+StringRef InputArgList::MakeArgStringRef(StringRef Str) const {
   return getArgString(MakeIndex(Str));
 }
 
 //
 
 DerivedArgList::DerivedArgList(const InputArgList &BaseArgs)
     : BaseArgs(BaseArgs) {}
 
-const char *DerivedArgList::MakeArgStringRef(StringRef Str) const {
+StringRef DerivedArgList::MakeArgStringRef(StringRef Str) const {
   return BaseArgs.MakeArgString(Str);
 }
 
 void DerivedArgList::AddSynthesizedArg(Arg *A) {
   SynthesizedArgs.push_back(std::unique_ptr<Arg>(A));
 }
 
 Arg *DerivedArgList::MakeFlagArg(const Arg *BaseArg, const Option Opt) const {
Arg *DerivedArgList::MakeSeparateArg(const Arg *BaseArg, const Option Opt,
   return SynthesizedArgs.back().get();
 }
 
 Arg *DerivedArgList::MakeJoinedArg(const Arg *BaseArg, const Option Opt,
                                    StringRef Value) const {
   unsigned Index = BaseArgs.MakeIndex((Opt.getName() + Value).str());
   SynthesizedArgs.push_back(make_unique<Arg>(
       Opt, MakeArgString(Opt.getPrefix() + Opt.getName()), Index,
-      BaseArgs.getArgString(Index) + Opt.getName().size(), BaseArg));
+      BaseArgs.getArgString(Index).drop_front(Opt.getName().size()), BaseArg));
   return SynthesizedArgs.back().get();
 }

llvm/lib/Option/OptTable.cpp

 using namespace llvm::opt;
 
 namespace llvm {
 namespace opt {
 
 // Ordering on Info. The ordering is *almost* case-insensitive lexicographic,
 // with an exceptions. '\0' comes at the end of the alphabet instead of the
 // beginning (thus options precede any other options which prefix them).
-static int StrCmpOptionNameIgnoreCase(const char *A, const char *B) {
-  const char *X = A, *Y = B;
-  char a = tolower(*A), b = tolower(*B);
+static int StrCmpOptionNameIgnoreCase(StringRef A, StringRef B) {
+  const char *X = A.data(), *Y = B.data();
+  char a = tolower(*X), b = tolower(*Y);
   while (a == b) {
     if (a == '\0')
       return 0;
 
     a = tolower(*++X);
     b = tolower(*++Y);
   }
 
   if (a == '\0') // A is a prefix of B.
     return 1;
   if (b == '\0') // B is a prefix of A.
     return -1;
 
   // Otherwise lexicographic.
   return (a < b) ? -1 : 1;
 }
 
 #ifndef NDEBUG
-static int StrCmpOptionName(const char *A, const char *B) {
+static int StrCmpOptionName(StringRef A, StringRef B) {
   if (int N = StrCmpOptionNameIgnoreCase(A, B))
     return N;
-  return strcmp(A, B);
+  return A.compare(B);
 }
 
 static inline bool operator<(const OptTable::Info &A, const OptTable::Info &B) {
   if (&A == &B)
     return false;
 
   if (int N = StrCmpOptionName(A.Name, B.Name))
     return N < 0;
#ifndef NDEBUG
   }
 #endif
 
   // Build prefixes.
   for (unsigned i = FirstSearchableIndex + 1, e = getNumOptions() + 1;
                 i != e; ++i) {
     if (const char *const *P = getInfo(i).Prefixes) {
       for (; *P != nullptr; ++P) {
-        PrefixesUnion.insert(*P);
+        PrefixesUnion.insert(StringRef(*P));
       }
     }
   }
 
   // Build prefix chars.
   for (llvm::StringSet<>::const_iterator I = PrefixesUnion.begin(),
                                          E = PrefixesUnion.end(); I != E; ++I) {
     StringRef Prefix = I->getKey();
static unsigned matchOption(const OptTable::Info *I, StringRef Str,
   }
   return 0;
 }
 
 Arg *OptTable::ParseOneArg(const ArgList &Args, unsigned &Index,
                            unsigned FlagsToInclude,
                            unsigned FlagsToExclude) const {
   unsigned Prev = Index;
-  const char *Str = Args.getArgString(Index);
+  auto Str = Args.getArgString(Index);
 
   // Anything that doesn't start with PrefixesUnion is an input, as is '-'
   // itself.
   if (isInput(PrefixesUnion, Str))
     return new Arg(getOption(TheInputOptionID), Str, Index++, Str);
 
   const Info *Start = OptionInfos.begin() + FirstSearchableIndex;
   const Info *End = OptionInfos.end();
for (; Start != End; ++Start) {
     Option Opt(Start, this);
 
     if (FlagsToInclude && !Opt.hasFlag(FlagsToInclude))
       continue;
     if (Opt.hasFlag(FlagsToExclude))
       continue;
 
     // See if this option matches.
-    if (Arg *A = Opt.accept(Args, Index, ArgSize))
+    if (Arg *A = Opt.accept(Args, Index, ArgSize)) {
       return A;
+    }
 
     // Otherwise, see if this argument was missing values.
     if (Prev != Index)
       return nullptr;
   }
 
   // If we failed to find an option and this arg started with /, then it's
   // probably an input path.
   if (Str[0] == '/')
     return new Arg(getOption(TheInputOptionID), Str, Index++, Str);
 
   return new Arg(getOption(TheUnknownOptionID), Str, Index++, Str);
 }
 
-InputArgList OptTable::ParseArgs(ArrayRef<const char *> ArgArr,
+InputArgList OptTable::ParseArgs(ArrayRef<StringRef> ArgArr,
                                  unsigned &MissingArgIndex,
                                  unsigned &MissingArgCount,
                                  unsigned FlagsToInclude,
                                  unsigned FlagsToExclude) const {
-  InputArgList Args(ArgArr.begin(), ArgArr.end());
+  InputArgList Args(ArgArr);
 
   // FIXME: Handle '@' args (or at least error on them).
 
   MissingArgIndex = MissingArgCount = 0;
   unsigned Index = 0, End = ArgArr.size();
   while (Index < End) {
     // Ingore nullptrs, they are response file's EOL markers
-    if (Args.getArgString(Index) == nullptr) {
+    if (Args.getArgString(Index).empty()) {
       ++Index;
       continue;
     }
     // Ignore empty arguments (other things may still take them as arguments).
     StringRef Str = Args.getArgString(Index);
     if (Str == "") {
       ++Index;
       continue;
static const char *getOptionHelpGroup(const OptTable &Opts, OptSpecifier Id) {
   // FIXME: Split out option groups.
   if (const char *GroupHelp = Opts.getOptionHelpText(GroupID))
     return GroupHelp;
 
   // Otherwise keep looking.
   return getOptionHelpGroup(Opts, GroupID);
 }
 
-void OptTable::PrintHelp(raw_ostream &OS, const char *Name, const char *Title,
+void OptTable::PrintHelp(raw_ostream &OS, StringRef Name, StringRef Title,
                          bool ShowHidden) const {
   PrintHelp(OS, Name, Title, /*Include*/ 0, /*Exclude*/
             (ShowHidden ? 0 : HelpHidden));
 }
 
 
-void OptTable::PrintHelp(raw_ostream &OS, const char *Name, const char *Title,
+void OptTable::PrintHelp(raw_ostream &OS, StringRef Name, StringRef Title,
                          unsigned FlagsToInclude,
                          unsigned FlagsToExclude) const {
   OS << "OVERVIEW: " << Title << "\n";
   OS << '\n';
   OS << "USAGE: " << Name << " [options] <inputs>\n";
   OS << '\n';
 
   // Render help text into a map of group-name to a list of (option, help)

llvm/lib/Option/Option.cpp

 
 Arg *Option::accept(const ArgList &Args,
                     unsigned &Index,
                     unsigned ArgSize) const {
   const Option &UnaliasedOption = getUnaliasedOption();
   StringRef Spelling;
   // If the option was an alias, get the spelling from the unaliased one.
   if (getID() == UnaliasedOption.getID()) {
-    Spelling = StringRef(Args.getArgString(Index), ArgSize);
+    assert(ArgSize <= Args.getArgString(Index).size() && "Overflow!");
+    Spelling = StringRef(Args.getArgString(Index).data(), ArgSize);
   } else {
     Spelling = Args.MakeArgString(Twine(UnaliasedOption.getPrefix()) +
                                   Twine(UnaliasedOption.getName()));
   }
 
   switch (getKind()) {
   case FlagClass: {
-    if (ArgSize != strlen(Args.getArgString(Index)))
+    if (ArgSize != Args.getArgString(Index).size())
       return nullptr;
 
     Arg *A = new Arg(UnaliasedOption, Spelling, Index++);
     if (getAliasArgs()) {
       const char *Val = getAliasArgs();
       while (*Val != '\0') {
-        A->getValues().push_back(Val);
+        StringRef ValStr(Val);
+        A->getValues().push_back(ValStr);
 
         // Move past the '\0' to the next argument.
-        Val += strlen(Val) + 1;
+        Val += ValStr.size() + 1;
       }
     }
 
     if (UnaliasedOption.getKind() == JoinedClass && !getAliasArgs())
       // A Flag alias for a Joined option must provide an argument.
       A->getValues().push_back("");
 
     return A;
   }
   case JoinedClass: {
-    const char *Value = Args.getArgString(Index) + ArgSize;
+    StringRef Value = Args.getArgString(Index).drop_front(ArgSize);
     return new Arg(UnaliasedOption, Spelling, Index++, Value);
   }
   case CommaJoinedClass: {
     // Always matches.
-    const char *Str = Args.getArgString(Index) + ArgSize;
+    const char *Str = Args.getArgString(Index).drop_front(ArgSize).data();
     Arg *A = new Arg(UnaliasedOption, Spelling, Index++);
 
     // Parse out the comma separated values.
     const char *Prev = Str;
     for (;; ++Str) {
       char c = *Str;
 
       if (!c || c == ',') {
         if (Prev != Str) {
           char *Value = new char[Str - Prev + 1];
           memcpy(Value, Prev, Str - Prev);
           Value[Str - Prev] = '\0';
-          A->getValues().push_back(Value);
+          A->getValues().push_back(StringRef(Value, Str - Prev));
         }
 
         if (!c)
           break;
 
         Prev = Str + 1;
       }
     }
     A->setOwnsValues(true);
 
     return A;
   }
   case SeparateClass:
     // Matches iff this is an exact match.
-    // FIXME: Avoid strlen.
-    if (ArgSize != strlen(Args.getArgString(Index)))
+    if (ArgSize != Args.getArgString(Index).size())
       return nullptr;
 
     Index += 2;
     if (Index > Args.getNumInputArgStrings() ||
-        Args.getArgString(Index - 1) == nullptr)
+        Args.getArgString(Index - 1).empty())
       return nullptr;
 
     return new Arg(UnaliasedOption, Spelling,
                    Index - 2, Args.getArgString(Index - 1));
   case MultiArgClass: {
     // Matches iff this is an exact match.
-    // FIXME: Avoid strlen.
-    if (ArgSize != strlen(Args.getArgString(Index)))
+    if (ArgSize != Args.getArgString(Index).size())
       return nullptr;
 
     Index += 1 + getNumArgs();
     if (Index > Args.getNumInputArgStrings())
       return nullptr;
 
     Arg *A = new Arg(UnaliasedOption, Spelling, Index - 1 - getNumArgs(),
                       Args.getArgString(Index - getNumArgs()));
     for (unsigned i = 1; i != getNumArgs(); ++i)
       A->getValues().push_back(Args.getArgString(Index - getNumArgs() + i));
     return A;
   }
   case JoinedOrSeparateClass: {
     // If this is not an exact match, it is a joined arg.
-    // FIXME: Avoid strlen.
-    if (ArgSize != strlen(Args.getArgString(Index))) {
-      const char *Value = Args.getArgString(Index) + ArgSize;
+    if (ArgSize != Args.getArgString(Index).size()) {
+      auto Value = Args.getArgString(Index).drop_front(ArgSize);
       return new Arg(*this, Spelling, Index++, Value);
     }
 
     // Otherwise it must be separate.
     Index += 2;
     if (Index > Args.getNumInputArgStrings() ||
-        Args.getArgString(Index - 1) == nullptr)
+        Args.getArgString(Index - 1).empty())
       return nullptr;
 
     return new Arg(UnaliasedOption, Spelling,
                    Index - 2, Args.getArgString(Index - 1));
   }
   case JoinedAndSeparateClass:
     // Always matches.
     Index += 2;
     if (Index > Args.getNumInputArgStrings() ||
-        Args.getArgString(Index - 1) == nullptr)
+        Args.getArgString(Index - 1).empty())
       return nullptr;
 
     return new Arg(UnaliasedOption, Spelling, Index - 2,
-                   Args.getArgString(Index - 2) + ArgSize,
+                   Args.getArgString(Index - 2).drop_front(ArgSize),
                    Args.getArgString(Index - 1));
   case RemainingArgsClass: {
     // Matches iff this is an exact match.
-    // FIXME: Avoid strlen.
-    if (ArgSize != strlen(Args.getArgString(Index)))
+    if (ArgSize != Args.getArgString(Index).size())
       return nullptr;
     Arg *A = new Arg(UnaliasedOption, Spelling, Index++);
     while (Index < Args.getNumInputArgStrings() &&
-           Args.getArgString(Index) != nullptr)
+           !Args.getArgString(Index).empty())
       A->getValues().push_back(Args.getArgString(Index++));
     return A;
   }
   case RemainingArgsJoinedClass: {
     Arg *A = new Arg(UnaliasedOption, Spelling, Index);
-    if (ArgSize != strlen(Args.getArgString(Index))) {
+    if (ArgSize != Args.getArgString(Index).size()) {
       // An inexact match means there is a joined arg.
-      A->getValues().push_back(Args.getArgString(Index) + ArgSize);
+      A->getValues().push_back(Args.getArgString(Index).drop_front(ArgSize));
     }
     Index++;
     while (Index < Args.getNumInputArgStrings() &&
-           Args.getArgString(Index) != nullptr)
+           !Args.getArgString(Index).empty())
       A->getValues().push_back(Args.getArgString(Index++));
     return A;
   }
 
   default:
     llvm_unreachable("Invalid option kind!");
   }
 }

llvm/lib/Support/CommandLine.cpp

CommandLineParser() : ActiveSubCommand(nullptr) {
     registerSubCommand(&*TopLevelSubCommand);
     registerSubCommand(&*AllSubCommands);
   }
 
   void ResetAllOptionOccurrences();
 
   bool ParseCommandLineOptions(int argc, const char *const *argv,
                                StringRef Overview, bool IgnoreErrors);
+  bool ParseCommandLineOptions(int argc, ArrayRef<StringRef> argv,
+                               StringRef Overview = "",
+                               bool IgnoreErrors = false);
 
   void addLiteralOption(Option &Opt, SubCommand *SC, StringRef Name) {
     if (Opt.hasArgStr())
       return;
     if (!SC->OptionsMap.insert(std::make_pair(Name, &Opt)).second) {
       errs() << ProgramName << ": CommandLine Error: Option '" << Name
              << "' registered more than once!\n";
       report_fatal_error("inconsistency in registered CommandLine options");
static bool CommaSeparateAndAddOccurrence(Option *Handler, unsigned pos,
   return Handler->addOccurrence(pos, ArgName, Value, MultiArg);
 }
 
 /// ProvideOption - For Value, this differentiates between an empty value ("")
 /// and a null value (StringRef()).  The later is accepted for arguments that
 /// don't allow a value (-foo) the former is rejected (-foo=).
 static inline bool ProvideOption(Option *Handler, StringRef ArgName,
                                  StringRef Value, int argc,
-                                 const char *const *argv, int &i) {
+                                 ArrayRef<StringRef> argv, int &i) {
   // Is this a multi-argument option?
   unsigned NumAdditionalVals = Handler->getNumAdditionalVals();
 
   // Enforce value requirements
   switch (Handler->getValueExpectedFlag()) {
   case ValueRequired:
     if (!Value.data()) { // No value specified?
       if (i + 1 >= argc)
         return Handler->error("requires a value!");
       // Steal the next argument, like for '-o filename'
-      assert(argv && "null check");
+      assert((unsigned)i < argv.size() && "bound check");
       Value = StringRef(argv[++i]);
     }
     break;
   case ValueDisallowed:
     if (NumAdditionalVals > 0)
       return Handler->error("multi-valued option specified"
                             " with ValueDisallowed modifier!");
 
if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg))
       return true;
     --NumAdditionalVals;
     MultiArg = true;
   }
 
   while (NumAdditionalVals > 0) {
     if (i + 1 >= argc)
       return Handler->error("not enough values!");
-    assert(argv && "null check");
+    assert((unsigned)i < argv.size() && "bound check");
     Value = StringRef(argv[++i]);
 
     if (CommaSeparateAndAddOccurrence(Handler, i, ArgName, Value, MultiArg))
       return true;
     MultiArg = true;
     --NumAdditionalVals;
   }
   return false;
 }
 
 static bool ProvidePositionalOption(Option *Handler, StringRef Arg, int i) {
   int Dummy = i;
-  return ProvideOption(Handler, Handler->ArgStr, Arg, 0, nullptr, Dummy);
+  return ProvideOption(Handler, Handler->ArgStr, Arg, 0, StringRef(), Dummy);
 }
 
 // Option predicates...
 static inline bool isGrouping(const Option *O) {
   return O->getFormattingFlag() == cl::Grouping;
 }
 static inline bool isPrefixedOrGrouping(const Option *O) {
   return isGrouping(O) || O->getFormattingFlag() == cl::Prefix;
do {
     Arg = Arg.substr(Length);
 
     // Because ValueRequired is an invalid flag for grouped arguments,
     // we don't need to pass argc/argv in.
     assert(PGOpt->getValueExpectedFlag() != cl::ValueRequired &&
            "Option can not be cl::Grouping AND cl::ValueRequired!");
     int Dummy = 0;
     ErrorParsing |=
-        ProvideOption(PGOpt, OneArgName, StringRef(), 0, nullptr, Dummy);
+        ProvideOption(PGOpt, OneArgName, StringRef(), 0, StringRef(), Dummy);
 
     // Get the next grouping option.
     PGOpt = getOptionPred(Arg, Length, isGrouping, OptionsMap);
   } while (PGOpt && Length != Arg.size());
 
   // Return the last option with Arg cut down to just the last one.
   return PGOpt;
 }
 
 static bool RequiresValue(const Option *O) {
   return O->getNumOccurrencesFlag() == cl::Required ||
          O->getNumOccurrencesFlag() == cl::OneOrMore;
 }
 
 static bool EatsUnboundedNumberOfValues(const Option *O) {
   return O->getNumOccurrencesFlag() == cl::ZeroOrMore ||
          O->getNumOccurrencesFlag() == cl::OneOrMore;
 }
 
 static bool isWhitespace(char C) { return strchr(" \t\n\r\f\v", C); }
 
 static bool isQuote(char C) { return C == '\"' || C == '\''; }
 
 void cl::TokenizeGNUCommandLine(StringRef Src, StringSaver &Saver,
-                                SmallVectorImpl<const char *> &NewArgv,
+                                SmallVectorImpl<StringRef> &NewArgv,
                                 bool MarkEOLs) {
   SmallString<128> Token;
   for (size_t I = 0, E = Src.size(); I != E; ++I) {
     // Consume runs of whitespace.
     if (Token.empty()) {
       while (I != E && isWhitespace(Src[I])) {
         // Mark the end of lines in response files
         if (MarkEOLs && Src[I] == '\n')
-          NewArgv.push_back(nullptr);
+          NewArgv.push_back(StringRef());
         ++I;
       }
       if (I == E)
         break;
     }
 
     // Backslash escapes the next character.
     if (I + 1 < E && Src[I] == '\\') {
for (size_t I = 0, E = Src.size(); I != E; ++I) {
     Token.push_back(Src[I]);
   }
 
   // Append the last token after hitting EOF with no whitespace.
   if (!Token.empty())
     NewArgv.push_back(Saver.save(StringRef(Token)).data());
   // Mark the end of response files
   if (MarkEOLs)
-    NewArgv.push_back(nullptr);
+    NewArgv.push_back(StringRef());
 }
 
 /// Backslashes are interpreted in a rather complicated way in the Windows-style
 /// command line, because backslashes are used both to separate path and to
 /// escape double quote. This method consumes runs of backslashes as well as the
 /// following double quote if it's escaped.
 ///
 ///  * If an even number of backslashes is followed by a double quote, one
if (FollowedByDoubleQuote) {
     Token.push_back('"');
     return I;
   }
   Token.append(BackslashCount, '\\');
   return I - 1;
 }
 
 void cl::TokenizeWindowsCommandLine(StringRef Src, StringSaver &Saver,
-                                    SmallVectorImpl<const char *> &NewArgv,
+                                    SmallVectorImpl<StringRef> &NewArgv,
                                     bool MarkEOLs) {
   SmallString<128> Token;
 
   // This is a small state machine to consume characters until it reaches the
   // end of the source string.
   enum { INIT, UNQUOTED, QUOTED } State = INIT;
   for (size_t I = 0, E = Src.size(); I != E; ++I) {
     // INIT state indicates that the current input index is at the start of
     // the string or between tokens.
     if (State == INIT) {
       if (isWhitespace(Src[I])) {
         // Mark the end of lines in response files
         if (MarkEOLs && Src[I] == '\n')
-          NewArgv.push_back(nullptr);
+          NewArgv.push_back(StringRef());
         continue;
       }
       if (Src[I] == '"') {
         State = QUOTED;
         continue;
       }
       if (Src[I] == '\\') {
         I = parseBackslash(Src, I, Token);
for (size_t I = 0, E = Src.size(); I != E; ++I) {
     if (State == UNQUOTED) {
       // Whitespace means the end of the token.
       if (isWhitespace(Src[I])) {
         NewArgv.push_back(Saver.save(StringRef(Token)).data());
         Token.clear();
         State = INIT;
         // Mark the end of lines in response files
         if (MarkEOLs && Src[I] == '\n')
-          NewArgv.push_back(nullptr);
+          NewArgv.push_back(StringRef());
         continue;
       }
       if (Src[I] == '"') {
         State = QUOTED;
         continue;
       }
       if (Src[I] == '\\') {
         I = parseBackslash(Src, I, Token);
if (State == QUOTED) {
       Token.push_back(Src[I]);
     }
   }
   // Append the last token after hitting EOF with no whitespace.
   if (!Token.empty())
     NewArgv.push_back(Saver.save(StringRef(Token)).data());
   // Mark the end of response files
   if (MarkEOLs)
-    NewArgv.push_back(nullptr);
+    NewArgv.push_back(StringRef());
 }
 
 // It is called byte order marker but the UTF-8 BOM is actually not affected
 // by the host system's endianness.
 static bool hasUTF8ByteOrderMark(ArrayRef<char> S) {
   return (S.size() >= 3 && S[0] == '\xef' && S[1] == '\xbb' && S[2] == '\xbf');
 }
 
-static bool ExpandResponseFile(const char *FName, StringSaver &Saver,
+static bool ExpandResponseFile(StringRef FName, StringSaver &Saver,
                                TokenizerCallback Tokenizer,
-                               SmallVectorImpl<const char *> &NewArgv,
+                               SmallVectorImpl<StringRef> &NewArgv,
                                bool MarkEOLs = false) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> MemBufOrErr =
       MemoryBuffer::getFile(FName);
   if (!MemBufOrErr)
     return false;
   MemoryBuffer &MemBuf = *MemBufOrErr.get();
   StringRef Str(MemBuf.getBufferStart(), MemBuf.getBufferSize());
 
static bool ExpandResponseFile(StringRef FName, StringSaver &Saver,
   Tokenizer(Str, Saver, NewArgv, MarkEOLs);
 
   return true;
 }
 
 /// \brief Expand response files on a command line recursively using the given
 /// StringSaver and tokenization strategy.
 bool cl::ExpandResponseFiles(StringSaver &Saver, TokenizerCallback Tokenizer,
-                             SmallVectorImpl<const char *> &Argv,
-                             bool MarkEOLs) {
+                             SmallVectorImpl<StringRef> &Argv, bool MarkEOLs) {
   unsigned RspFiles = 0;
   bool AllExpanded = true;
 
   // Don't cache Argv.size() because it can change.
   for (unsigned I = 0; I != Argv.size();) {
-    const char *Arg = Argv[I];
+    StringRef Arg = Argv[I];
     // Check if it is an EOL marker
-    if (Arg == nullptr) {
+    if (Arg.empty()) {
       ++I;
       continue;
     }
     if (Arg[0] != '@') {
       ++I;
       continue;
     }
 
     // If we have too many response files, leave some unexpanded.  This avoids
     // crashing on self-referential response files.
     if (RspFiles++ > 20)
       return false;
 
     // Replace this response file argument with the tokenization of its
     // contents.  Nested response files are expanded in subsequent iterations.
     // FIXME: If a nested response file uses a relative path, is it relative to
     // the cwd of the process or the response file?
-    SmallVector<const char *, 0> ExpandedArgv;
-    if (!ExpandResponseFile(Arg + 1, Saver, Tokenizer, ExpandedArgv,
+    SmallVector<StringRef, 0> ExpandedArgv;
+    if (!ExpandResponseFile(Arg.drop_front(1), Saver, Tokenizer, ExpandedArgv,
                             MarkEOLs)) {
       // We couldn't read this file, so we leave it in the argument stream and
       // move on.
       AllExpanded = false;
       ++I;
       continue;
     }
     Argv.erase(Argv.begin() + I);
void cl::ParseEnvironmentOptions(const char *progName, const char *envVar,
 
   // Get the environment variable they want us to parse options out of.
   llvm::Optional<std::string> envValue = sys::Process::GetEnv(StringRef(envVar));
   if (!envValue)
     return;
 
   // Get program's "name", which we wouldn't know without the caller
   // telling us.
-  SmallVector<const char *, 20> newArgv;
+  SmallVector<StringRef, 20> newArgv;
   BumpPtrAllocator A;
   StringSaver Saver(A);
   newArgv.push_back(Saver.save(progName).data());
 
   // Parse the value of the environment variable into a "command line"
   // and hand it off to ParseCommandLineOptions().
   TokenizeGNUCommandLine(*envValue, Saver, newArgv);
   int newArgc = static_cast<int>(newArgv.size());
-  ParseCommandLineOptions(newArgc, &newArgv[0], StringRef(Overview));
+
+  ParseCommandLineOptions(newArgc, newArgv, StringRef(Overview));
 }
 
 bool cl::ParseCommandLineOptions(int argc, const char *const *argv,
                                  StringRef Overview, bool IgnoreErrors) {
   return GlobalParser->ParseCommandLineOptions(argc, argv, Overview,
                                                IgnoreErrors);
 }
 
+bool cl::ParseCommandLineOptions(int argc, ArrayRef<StringRef> argv,
+                                 StringRef Overview, bool IgnoreErrors) {
+  return GlobalParser->ParseCommandLineOptions(argc, argv, Overview,
+                                               IgnoreErrors);
+}
+
 void CommandLineParser::ResetAllOptionOccurrences() {
   // So that we can parse different command lines multiple times in succession
   // we reset all option values to look like they have never been seen before.
   for (auto SC : RegisteredSubCommands) {
     for (auto &O : SC->OptionsMap)
       O.second->reset();
   }
 }
 
 bool CommandLineParser::ParseCommandLineOptions(int argc,
                                                 const char *const *argv,
                                                 StringRef Overview,
                                                 bool IgnoreErrors) {
+  SmallVector<StringRef, 32> Args;
+  Args.reserve(argc);
+  for (int ArgId = 0; ArgId < argc; ArgId++)
+    Args.push_back(StringRef(argv[ArgId]));
+  return ParseCommandLineOptions(argc, Args, Overview, IgnoreErrors);
+}
+
+bool CommandLineParser::ParseCommandLineOptions(int argc,
+                                                ArrayRef<StringRef> argv,
+                                                StringRef Overview,
+                                                bool IgnoreErrors) {
   assert(hasOptions() && "No options specified!");
 
   // Expand response files.
-  SmallVector<const char *, 20> newArgv(argv, argv + argc);
+  SmallVector<StringRef, 20> newArgv;
+  newArgv.append(argv.begin(), argv.end());
   BumpPtrAllocator A;
   StringSaver Saver(A);
   ExpandResponseFiles(Saver, TokenizeGNUCommandLine, newArgv);
-  argv = &newArgv[0];
+  argv = newArgv;
   argc = static_cast<int>(newArgv.size());
 
   // Copy the program name into ProgName, making sure not to overflow it.
   ProgramName = sys::path::filename(StringRef(argv[0]));
 
   ProgramOverview = Overview;
   bool ErrorParsing = false;
 
   // Check out the positional arguments to collect information about them.
   unsigned NumPositionalRequired = 0;
 
   // Determine whether or not there are an unlimited number of positionals
   bool HasUnlimitedPositionals = false;
 
   int FirstArg = 1;
   SubCommand *ChosenSubCommand = &*TopLevelSubCommand;
-  if (argc >= 2 && argv[FirstArg][0] != '-') {
+  if (argc >= 2 && !argv[FirstArg].startswith("-")) {
     // If the first argument specifies a valid subcommand, start processing
     // options from the second argument.
     ChosenSubCommand = LookupSubCommand(StringRef(argv[FirstArg]));
     if (ChosenSubCommand != &*TopLevelSubCommand)
       FirstArg = 2;
   }
   GlobalParser->ActiveSubCommand = ChosenSubCommand;
 
for (int i = FirstArg; i < argc; ++i) {
     std::string NearestHandlerString;
     StringRef Value;
     StringRef ArgName = "";
 
     // Check to see if this is a positional argument.  This argument is
     // considered to be positional if it doesn't start with '-', if it is "-"
     // itself, or if we have seen "--" already.
     //
-    if (argv[i][0] != '-' || argv[i][1] == 0 || DashDashFound) {
+    if (!argv[i].startswith("-") || argv[i].size() == 1 || DashDashFound) {
       // Positional argument!
       if (ActivePositionalArg) {
         ProvidePositionalOption(ActivePositionalArg, StringRef(argv[i]), i);
         continue; // We are done!
       }
 
       if (!PositionalOpts.empty()) {
         PositionalVals.push_back(std::make_pair(StringRef(argv[i]), i));
 
         // All of the positional arguments have been fulfulled, give the rest to
         // the consume after option... if it's specified...
         //
         if (PositionalVals.size() >= NumPositionalRequired && ConsumeAfterOpt) {
           for (++i; i < argc; ++i)
             PositionalVals.push_back(std::make_pair(StringRef(argv[i]), i));
           break; // Handle outside of the argument processing loop...
         }
 
         // Delay processing positional arguments until the end...
         continue;
       }
-    } else if (argv[i][0] == '-' && argv[i][1] == '-' && argv[i][2] == 0 &&
-               !DashDashFound) {
+    } else if (argv[i] == "--" && !DashDashFound) {
       DashDashFound = true; // This is the mythical "--"?
       continue;             // Don't try to process it as an argument itself.
     } else if (ActivePositionalArg &&
                (ActivePositionalArg->getMiscFlags() & PositionalEatsArgs)) {
       // If there is a positional argument eating options, check to see if this
       // option is another positional argument.  If so, treat it as an argument,
       // otherwise feed it to the eating positional.
-      ArgName = StringRef(argv[i] + 1);
+      ArgName = argv[i].drop_front(1);
       // Eat leading dashes.
       while (!ArgName.empty() && ArgName[0] == '-')
         ArgName = ArgName.substr(1);
 
       Handler = LookupOption(*ChosenSubCommand, ArgName, Value);
       if (!Handler || Handler->getFormattingFlag() != cl::Positional) {
         ProvidePositionalOption(ActivePositionalArg, StringRef(argv[i]), i);
         continue; // We are done!
       }
 
     } else { // We start with a '-', must be an argument.
-      ArgName = StringRef(argv[i] + 1);
+      ArgName = argv[i].drop_front(1);
       // Eat leading dashes.
       while (!ArgName.empty() && ArgName[0] == '-')
         ArgName = ArgName.substr(1);
 
       Handler = LookupOption(*ChosenSubCommand, ArgName, Value);
 
       // Check to see if this "option" is really a prefixed or grouped argument.
       if (!Handler)

llvm/lib/Support/Unix/Process.inc

Optional<std::string> Process::GetEnv(StringRef Name) {
   std::string NameStr = Name.str();
   const char *Val = ::getenv(NameStr.c_str());
   if (!Val)
     return None;
   return std::string(Val);
 }
 
 std::error_code
-Process::GetArgumentVector(SmallVectorImpl<const char *> &ArgsOut,
+Process::GetArgumentVector(SmallVectorImpl<StringRef> &ArgsOut,
                            ArrayRef<const char *> ArgsIn,
                            SpecificBumpPtrAllocator<char> &) {
-  ArgsOut.append(ArgsIn.begin(), ArgsIn.end());
+  ArgsOut.reserve(ArgsIn.size());
+  for (auto Arg : ArgsIn)
+    ArgsOut.push_back(Arg);
 
   return std::error_code();
 }
 
 namespace {
 class FDCloser {
 public:
   FDCloser(int &FD) : FD(FD), KeepOpen(false) {}

llvm/lib/Support/Unix/Program.inc

llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
   OS << Contents;
 
   if (OS.has_error())
     return make_error_code(errc::io_error);
 
   return EC;
 }
 
-bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef<const char*> Args) {
+bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef<StringRef> Args) {
   static long ArgMax = sysconf(_SC_ARG_MAX);
 
   // System says no practical limit.
   if (ArgMax == -1)
     return true;
 
   // Conservatively account for space required by environment variables.
   long HalfArgMax = ArgMax / 2;
 
   size_t ArgLength = Program.size() + 1;
-  for (ArrayRef<const char*>::iterator I = Args.begin(), E = Args.end();
+  for (auto I = Args.begin(), E = Args.end();
        I != E; ++I) {
-    ArgLength += strlen(*I) + 1;
+    ArgLength += I->size() + 1;
     if (ArgLength > size_t(HalfArgMax)) {
       return false;
     }
   }
   return true;
 }
 }

llvm/lib/Support/Windows/Process.inc

Optional<std::string> Process::GetEnv(StringRef Name) {
   // Convert the result from UTF-16 to UTF-8.
   SmallVector<char, MAX_PATH> Res;
   if (windows::UTF16ToUTF8(Buf.data(), Size, Res))
     return None;
   return std::string(Res.data());
 }
 
 static void AllocateAndPush(const SmallVectorImpl<char> &S,
-                            SmallVectorImpl<const char *> &Vector,
+                            SmallVectorImpl<StringRef> &Vector,
                             SpecificBumpPtrAllocator<char> &Allocator) {
   char *Buffer = Allocator.Allocate(S.size() + 1);
   ::memcpy(Buffer, S.data(), S.size());
   Buffer[S.size()] = '\0';
-  Vector.push_back(Buffer);
+  Vector.push_back(StringRef(Buffer, S.size()));
 }
 
 /// Convert Arg from UTF-16 to UTF-8 and push it onto Args.
 static std::error_code
-ConvertAndPushArg(const wchar_t *Arg, SmallVectorImpl<const char *> &Args,
+ConvertAndPushArg(const wchar_t *Arg, SmallVectorImpl<StringRef> &Args,
                   SpecificBumpPtrAllocator<char> &Allocator) {
   SmallVector<char, MAX_PATH> ArgString;
   if (std::error_code ec = windows::UTF16ToUTF8(Arg, wcslen(Arg), ArgString))
     return ec;
   AllocateAndPush(ArgString, Args, Allocator);
   return std::error_code();
 }
 
 /// \brief Perform wildcard expansion of Arg, or just push it into Args if it
 /// doesn't have wildcards or doesn't match any files.
 static std::error_code
-WildcardExpand(const wchar_t *Arg, SmallVectorImpl<const char *> &Args,
+WildcardExpand(const wchar_t *Arg, SmallVectorImpl<StringRef> &Args,
                SpecificBumpPtrAllocator<char> &Allocator) {
   if (!wcspbrk(Arg, L"*?")) {
     // Arg does not contain any wildcard characters. This is the common case.
     return ConvertAndPushArg(Arg, Args, Allocator);
   }
 
   if (wcscmp(Arg, L"/?") == 0 || wcscmp(Arg, L"-?") == 0) {
     // Don't wildcard expand /?. Always treat it as an option.
do {
     Dir.resize(DirSize);
   } while (FindNextFileW(FindHandle, &FileData));
 
   FindClose(FindHandle);
   return ec;
 }
 
 static std::error_code
-ExpandShortFileName(const wchar_t *Arg, SmallVectorImpl<const char *> &Args,
+ExpandShortFileName(const wchar_t *Arg, SmallVectorImpl<StringRef> &Args,
                     SpecificBumpPtrAllocator<char> &Allocator) {
   SmallVector<wchar_t, MAX_PATH> LongPath;
   DWORD Length = GetLongPathNameW(Arg, LongPath.data(), LongPath.capacity());
   if (Length == 0)
     return mapWindowsError(GetLastError());
   if (Length > LongPath.capacity()) {
     // We're not going to try to deal with paths longer than MAX_PATH, so we'll
     // treat this as an error.  GetLastError() returns ERROR_SUCCESS, which
     // isn't useful, so we'll hardcode an appropriate error value.
     return mapWindowsError(ERROR_INSUFFICIENT_BUFFER);
   }
   LongPath.set_size(Length);
   return ConvertAndPushArg(LongPath.data(), Args, Allocator);
 }
 
 std::error_code
-Process::GetArgumentVector(SmallVectorImpl<const char *> &Args,
+Process::GetArgumentVector(SmallVectorImpl<StringRef> &Args,
                            ArrayRef<const char *>,
                            SpecificBumpPtrAllocator<char> &ArgAllocator) {
   int ArgCount;
   wchar_t **UnicodeCommandLine =
       CommandLineToArgvW(GetCommandLineW(), &ArgCount);
   if (!UnicodeCommandLine)
     return mapWindowsError(::GetLastError());
 

llvm/lib/Support/Windows/Program.inc

llvm::sys::writeFileWithEncoding(StringRef FileName, StringRef Contents,
   }
 
   if (OS.has_error())
     return make_error_code(errc::io_error);
 
   return EC;
 }
 
-bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef<const char*> Args) {
+bool llvm::sys::commandLineFitsWithinSystemLimits(StringRef Program, ArrayRef<StringRef> Args) {
   // The documented max length of the command line passed to CreateProcess.
   static const size_t MaxCommandStringLength = 32768;
   // Account for the trailing space for the program path and the
   // trailing NULL of the last argument.
   size_t ArgLength = ArgLenWithQuotes(Program.str().c_str()) + 2;
-  for (ArrayRef<const char*>::iterator I = Args.begin(), E = Args.end();
+  for (auto I = Args.begin(), E = Args.end();
        I != E; ++I) {
     // Account for the trailing space for every arg
-    ArgLength += ArgLenWithQuotes(*I) + 1;
+    ArgLength += ArgLenWithQuotes(I->str().c_str()) + 1;
     if (ArgLength > MaxCommandStringLength) {
       return false;
     }
   }
   return true;
 }
 }

llvm/tools/llvm-ar/llvm-ar.cpp

int main(int argc, char **argv) {
   llvm_shutdown_obj Y;  // Call llvm_shutdown() on exit.
 
   llvm::InitializeAllTargetInfos();
   llvm::InitializeAllTargetMCs();
   llvm::InitializeAllAsmParsers();
 
   StringRef Stem = sys::path::stem(ToolName);
   if (Stem.find("ranlib") == StringRef::npos &&
-      Stem.find("lib") != StringRef::npos)
-    return libDriverMain(makeArrayRef(argv, argc));
+      Stem.find("lib") != StringRef::npos) {
+    SmallVector<StringRef, 20> Args;
+    for (int ArgId = 0; ArgId < argc; ArgId++) {
+      Args.push_back(StringRef(argv[ArgId]));
+    }
+    return libDriverMain(Args);
+  }
 
   // Have the command line options parsed and handle things
   // like --help and --version.
   cl::ParseCommandLineOptions(argc, argv,
     "LLVM Archiver (llvm-ar)\n\n"
     "  This program archives bitcode files into single libraries\n"
   );
 
   if (Stem.find("ranlib") != StringRef::npos)
     return ranlib_main();
   if (Stem.find("ar") != StringRef::npos)
     return ar_main();
   fail("Not ranlib, ar or lib!");
 }

llvm/tools/llvm-pdbdump/llvm-pdbdump.cpp

 
 int main(int argc_, const char *argv_[]) {
   // Print a stack trace if we signal out.
   sys::PrintStackTraceOnErrorSignal(argv_[0]);
   PrettyStackTraceProgram X(argc_, argv_);
 
   ExitOnErr.setBanner("llvm-pdbdump: ");
 
-  SmallVector<const char *, 256> argv;
+  SmallVector<StringRef, 256> argv;
   SpecificBumpPtrAllocator<char> ArgAllocator;
   ExitOnErr(errorCodeToError(sys::Process::GetArgumentVector(
       argv, makeArrayRef(argv_, argc_), ArgAllocator)));
 
   llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
 
-  cl::ParseCommandLineOptions(argv.size(), argv.data(), "LLVM PDB Dumper\n");
+  cl::ParseCommandLineOptions(argv.size(), argv, "LLVM PDB Dumper\n");
   if (!opts::raw::DumpBlockRangeOpt.empty()) {
     llvm::Regex R("^([0-9]+)(-([0-9]+))?$");
     llvm::SmallVector<llvm::StringRef, 2> Matches;
     if (!R.match(opts::raw::DumpBlockRangeOpt, &Matches)) {
       errs() << "Argument '" << opts::raw::DumpBlockRangeOpt
              << "' invalid format.\n";
       errs().flush();
       exit(1);

llvm/unittests/Option/OptionParsingTest.cpp

 namespace {
 class TestOptTable : public OptTable {
 public:
   TestOptTable(bool IgnoreCase = false)
     : OptTable(InfoTable, IgnoreCase) {}
 };
 }
 
-const char *Args[] = {
-  "-A",
-  "-Bhi",
-  "--C=desu",
-  "-C", "bye",
-  "-D,adena",
-  "-E", "apple", "bloom",
-  "-Fblarg",
-  "-F", "42",
-  "-Gchuu", "2"
-  };
+StringRef Args[] = {"-A",    "-Bhi",  "--C=desu", "-C", "bye", "-D,adena", "-E",
+                    "apple", "bloom", "-Fblarg",  "-F", "42",  "-Gchuu",   "2"};
 
 TEST(Option, OptionParsing) {
   TestOptTable T;
   unsigned MAI, MAC;
   InputArgList AL = T.ParseArgs(Args, MAI, MAC);
 
   // Check they all exist.
   EXPECT_TRUE(AL.hasArg(OPT_A));
TEST(Option, ParseWithFlagExclusions) {
   // Exclude flag1 to avoid parsing as OPT_C.
   AL = T.ParseArgs(Args, MAI, MAC,
                    /*FlagsToInclude=*/0,
                    /*FlagsToExclude=*/OptFlag1);
   EXPECT_TRUE(AL.hasArg(OPT_B));
   EXPECT_FALSE(AL.hasArg(OPT_C));
   EXPECT_TRUE(AL.hasArg(OPT_SLASH_C));
 
-  const char *NewArgs[] = { "/C", "foo", "--C=bar" };
+  StringRef NewArgs[] = {"/C", "foo", "--C=bar"};
   AL = T.ParseArgs(NewArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_SLASH_C));
   EXPECT_TRUE(AL.hasArg(OPT_C));
   EXPECT_EQ("foo", AL.getLastArgValue(OPT_SLASH_C));
   EXPECT_EQ("bar", AL.getLastArgValue(OPT_C));
 }
 
 TEST(Option, ParseAliasInGroup) {
   TestOptTable T;
   unsigned MAI, MAC;
 
-  const char *MyArgs[] = { "-I" };
+  StringRef MyArgs[] = {"-I"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_H));
 }
 
 TEST(Option, AliasArgs) {
   TestOptTable T;
   unsigned MAI, MAC;
 
-  const char *MyArgs[] = { "-J", "-Joo" };
+  StringRef MyArgs[] = {"-J", "-Joo"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_B));
   EXPECT_EQ("foo", AL.getAllArgValues(OPT_B)[0]);
   EXPECT_EQ("bar", AL.getAllArgValues(OPT_B)[1]);
 }
 
 TEST(Option, IgnoreCase) {
   TestOptTable T(true);
   unsigned MAI, MAC;
 
-  const char *MyArgs[] = { "-a", "-joo" };
+  StringRef MyArgs[] = {"-a", "-joo"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_B));
 }
 
 TEST(Option, DoNotIgnoreCase) {
   TestOptTable T;
   unsigned MAI, MAC;
 
-  const char *MyArgs[] = { "-a", "-joo" };
+  StringRef MyArgs[] = {"-a", "-joo"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_FALSE(AL.hasArg(OPT_A));
   EXPECT_FALSE(AL.hasArg(OPT_B));
 }
 
 TEST(Option, SlurpEmpty) {
   TestOptTable T;
   unsigned MAI, MAC;
 
-  const char *MyArgs[] = { "-A", "-slurp" };
+  StringRef MyArgs[] = {"-A", "-slurp"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_Slurp));
   EXPECT_EQ(0U, AL.getAllArgValues(OPT_Slurp).size());
 }
 
 TEST(Option, Slurp) {
   TestOptTable T;
   unsigned MAI, MAC;
 
-  const char *MyArgs[] = { "-A", "-slurp", "-B", "--", "foo" };
+  StringRef MyArgs[] = {"-A", "-slurp", "-B", "--", "foo"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_EQ(AL.size(), 2U);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_FALSE(AL.hasArg(OPT_B));
   EXPECT_TRUE(AL.hasArg(OPT_Slurp));
   EXPECT_EQ(3U, AL.getAllArgValues(OPT_Slurp).size());
   EXPECT_EQ("-B", AL.getAllArgValues(OPT_Slurp)[0]);
   EXPECT_EQ("--", AL.getAllArgValues(OPT_Slurp)[1]);
   EXPECT_EQ("foo", AL.getAllArgValues(OPT_Slurp)[2]);
 }
 
 TEST(Option, SlurpJoinedEmpty) {
   TestOptTable T;
   unsigned MAI, MAC;
 
-  const char *MyArgs[] = { "-A", "-slurpjoined" };
+  StringRef MyArgs[] = {"-A", "-slurpjoined"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
   EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined).size(), 0U);
 }
 
 TEST(Option, SlurpJoinedOneJoined) {
   TestOptTable T;
   unsigned MAI, MAC;
 
-  const char *MyArgs[] = { "-A", "-slurpjoinedfoo" };
+  StringRef MyArgs[] = {"-A", "-slurpjoinedfoo"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
   EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined).size(), 1U);
   EXPECT_EQ(AL.getAllArgValues(OPT_SlurpJoined)[0], "foo");
 }
 
 TEST(Option, SlurpJoinedAndSeparate) {
   TestOptTable T;
   unsigned MAI, MAC;
 
-  const char *MyArgs[] = { "-A", "-slurpjoinedfoo", "bar", "baz" };
+  StringRef MyArgs[] = {"-A", "-slurpjoinedfoo", "bar", "baz"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
   EXPECT_EQ(3U, AL.getAllArgValues(OPT_SlurpJoined).size());
   EXPECT_EQ("foo", AL.getAllArgValues(OPT_SlurpJoined)[0]);
   EXPECT_EQ("bar", AL.getAllArgValues(OPT_SlurpJoined)[1]);
   EXPECT_EQ("baz", AL.getAllArgValues(OPT_SlurpJoined)[2]);
 }
 
 TEST(Option, SlurpJoinedButSeparate) {
   TestOptTable T;
   unsigned MAI, MAC;
 
-  const char *MyArgs[] = { "-A", "-slurpjoined", "foo", "bar", "baz" };
+  StringRef MyArgs[] = {"-A", "-slurpjoined", "foo", "bar", "baz"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_TRUE(AL.hasArg(OPT_A));
   EXPECT_TRUE(AL.hasArg(OPT_SlurpJoined));
   EXPECT_EQ(3U, AL.getAllArgValues(OPT_SlurpJoined).size());
   EXPECT_EQ("foo", AL.getAllArgValues(OPT_SlurpJoined)[0]);
   EXPECT_EQ("bar", AL.getAllArgValues(OPT_SlurpJoined)[1]);
   EXPECT_EQ("baz", AL.getAllArgValues(OPT_SlurpJoined)[2]);
 }
 
 TEST(Option, FlagAliasToJoined) {
   TestOptTable T;
   unsigned MAI, MAC;
 
   // Check that a flag alias provides an empty argument to a joined option.
-  const char *MyArgs[] = { "-K" };
+  const StringRef MyArgs[] = {"-K"};
   InputArgList AL = T.ParseArgs(MyArgs, MAI, MAC);
   EXPECT_EQ(AL.size(), 1U);
   EXPECT_TRUE(AL.hasArg(OPT_B));
   EXPECT_EQ(1U, AL.getAllArgValues(OPT_B).size());
   EXPECT_EQ("", AL.getAllArgValues(OPT_B)[0]);
 }

llvm/unittests/Support/CommandLineTest.cpp

 TEST(CommandLineTest, UseOptionCategory) {
   StackOption<int> TestOption2("test-option", cl::cat(TestCategory));
 
   ASSERT_EQ(&TestCategory,TestOption2.Category) << "Failed to assign Option "
                                                   "Category.";
 }
 
 typedef void ParserFunction(StringRef Source, StringSaver &Saver,
-                            SmallVectorImpl<const char *> &NewArgv,
-                            bool MarkEOLs);
+                            SmallVectorImpl<StringRef> &NewArgv, bool MarkEOLs);
 
 void testCommandLineTokenizer(ParserFunction *parse, StringRef Input,
-                              const char *const Output[], size_t OutputSize) {
-  SmallVector<const char *, 0> Actual;
+                              const StringRef Output[], size_t OutputSize) {
+  SmallVector<StringRef, 0> Actual;
   BumpPtrAllocator A;
   StringSaver Saver(A);
   parse(Input, Saver, Actual, /*MarkEOLs=*/false);
   EXPECT_EQ(OutputSize, Actual.size());
   for (unsigned I = 0, E = Actual.size(); I != E; ++I) {
     if (I < OutputSize)
-      EXPECT_STREQ(Output[I], Actual[I]);
+      EXPECT_EQ(Output[I], Actual[I]);
   }
 }
 
 TEST(CommandLineTest, TokenizeGNUCommandLine) {
   const char Input[] =
       "foo\\ bar \"foo bar\" \'foo bar\' 'foo\\\\bar' -DFOO=bar\\(\\) "
       "foo\"bar\"baz C:\\\\src\\\\foo.cpp \"C:\\src\\foo.cpp\"";
-  const char *const Output[] = {
-      "foo bar",     "foo bar",   "foo bar",          "foo\\bar",
-      "-DFOO=bar()", "foobarbaz", "C:\\src\\foo.cpp", "C:srcfoo.cpp"};
+  const StringRef Output[] = {"foo bar",          "foo bar",     "foo bar",
+                              "foo\\bar",         "-DFOO=bar()", "foobarbaz",
+                              "C:\\src\\foo.cpp", "C:srcfoo.cpp"};
   testCommandLineTokenizer(cl::TokenizeGNUCommandLine, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, TokenizeWindowsCommandLine) {
   const char Input[] = "a\\b c\\\\d e\\\\\"f g\" h\\\"i j\\\\\\\"k \"lmn\" o pqr "
                       "\"st \\\"u\" \\v";
-  const char *const Output[] = { "a\\b", "c\\\\d", "e\\f g", "h\"i", "j\\\"k",
-                                 "lmn", "o", "pqr", "st \"u", "\\v" };
+  const StringRef Output[] = {"a\\b", "c\\\\d", "e\\f g", "h\"i",   "j\\\"k",
+                              "lmn",  "o",      "pqr",    "st \"u", "\\v"};
   testCommandLineTokenizer(cl::TokenizeWindowsCommandLine, Input, Output,
                            array_lengthof(Output));
 }
 
 TEST(CommandLineTest, AliasesWithArguments) {
   static const size_t ARGC = 3;
   const char *const Inputs[][ARGC] = {
     { "-tool", "-actual=x", "-extra" },