Add Utility/Environment class for handling... environments

[labath]

Summary

There was some confusion in the code about how to represent process
environment. Most of the code (ab)used the Args class for this purpose,
but some of it used a more basic StringList class instead. In either
case, the fact that the underlying abstraction did not provide primitive
operations for the typical environment operations meant that even a
simple operation like checking for an environment variable value was
several lines of code.

This patch adds a separate Environment class, which is essentialy a
llvm::StringMap<std::string> in disguise. To standard StringMap
functionality, it adds a couple of new functions, which are specific to
the environment use case:

• (most important) envp conversion for passing into execve() and likes. Instead of trying to maintain a constantly up-to-date envp view, it provides a function which creates a envp view on demand, with the expectation that this will be called as the very last thing before handing the value to the system function.
• insert(StringRef KeyEqValue) - splits KeyEqValue into (key, value) pair and inserts it into the environment map.
• compose(value_type KeyValue) - takes a map entry and converts in back into "KEY=VALUE" representation.

With this interface most of the environment-manipulating code becomes
one-liners. The only tricky part was maintaining compatibility in
SBLaunchInfo, which expects that the environment entries are accessible
by index and that the returned const char* is backed by the launch info
object (random access into maps is hard and the map stores the entry in
a deconstructed form, so we cannot just return a .c_str() value). To
solve this, I have the SBLaunchInfo convert the environment into the
"envp" form, and use it to answer the environment queries. Extra code is
added to make sure the envp version is always in sync.

(This also improves the layering situation as Args was in the Interpreter module
whereas Environment is in Utility.)

[zturner]

include/lldb/Utility/Environment.h

70–72 ↗

(On Diff #127378)

Why'd you decide to go with inserting an entire pre-formatted key value pair in the form {key}={value}, instead of having the function be insert(StringRef Key, StringRef Value)?

source/Host/macosx/Host.mm

763 ↗

(On Diff #127378)

Indentation is messed up here.

[labath]

include/lldb/Utility/Environment.h

70–72 ↗

(On Diff #127378)

The insert(key, value) form is still available (and used where appropriate). This is a convenience function because in a lot of the cases we only have the "KEY=VALUE" form handy (constructing from char**envp, reading the env over gdb-remote, ...), and I wanted to avoid having each user having to split this manually. I wouldn't be opposed to calling this something other than insert if you think it's confusing, but I think the functionality per-se is quite useful.

[labath]

re-clang-format the patch

[clayborg]

ok as long as we don't want to return const reference when returning Environment values in getters and setters.

include/lldb/Target/Platform.h

636 ↗

(On Diff #127384)

Do we want to return by value? Not a const reference?

include/lldb/Target/Target.h

118–119 ↗

(On Diff #127384)

set/get using reference instead of by value?

source/API/SBLaunchInfo.cpp

34 ↗

(On Diff #127384)

Seems like a lot of work to get indexed environment variable access. Should we not make the Environment class use a std::vector instead of a map? Not sure if environment variable order is ever important? Is so then the StringMap isn't what we want to use. I know we have it in our public API so we can't change it now and thus why we need this work around. Just thinking out loud

[labath]

include/lldb/Target/Platform.h

636 ↗

(On Diff #127384)

This object can come from the Host::GetEnvironment, which constructs it on-demand. Returning a reference would mean we need to cache a value in the host layer, but that's tricky as the environment can change during runtime, and you want to make sure you always return an up-to-date value.

I don't think this is an issue, as all the returns will be moves, so the situation will be the same as before this patch (where we also created a copy of the environment in the by-ref argument).

include/lldb/Target/Target.h

118–119 ↗

(On Diff #127384)

There is no persistent object object to back the reference for the getter (it's constructed from an OptionValueDictionary). Using a value for the setter is actually better, as that allows me to move-assign the environment object in the LaunchInfo. If the user calls this with a moved object then we get no copies.

source/API/SBLaunchInfo.cpp

34 ↗

(On Diff #127384)

I was thinking about the importance of variable order as well. I can certainly construct an application that will behave differently depending on the order of environment variables it is given. However, something like that seems unlikely to happen for real.

I actually started working on an order-preserving implementation, but then dropped it when I saw that we are already shoving the variables through a std::map in the OptionValueDictionary in target.env-vars setting. If we manage to drop that (OptionValueEnvironment?), then I think it would make sense to swap out this implementation for an order-preserving one. I would still keep the present map-like interface, as we do key-based lookup in quite a lot of places.

[clayborg]

Thanks for the explanation. Good to go.

lldb/trunk/include/lldb/API/SBLaunchInfo.h

 //===-- SBLaunchInfo.h ------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SBLaunchInfo_h_
 #define LLDB_SBLaunchInfo_h_
 
 #include "lldb/API/SBDefines.h"
 
+namespace lldb_private {
+class SBLaunchInfoImpl;
+}
+
 namespace lldb {
 
 class SBPlatform;
 class SBTarget;
 
 class LLDB_API SBLaunchInfo {
 public:
   SBLaunchInfo(const char **argv);
public:
   bool GetDetachOnError() const;
 
   void SetDetachOnError(bool enable);
 
 protected:
   friend class SBPlatform;
   friend class SBTarget;
 
-  lldb_private::ProcessLaunchInfo &ref();
-
   const lldb_private::ProcessLaunchInfo &ref() const;
+  void set_ref(const lldb_private::ProcessLaunchInfo &info);
 
-  ProcessLaunchInfoSP m_opaque_sp;
+  std::shared_ptr<lldb_private::SBLaunchInfoImpl> m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_SBLaunchInfo_h_

lldb/trunk/include/lldb/Host/Host.h

 //===-- Host.h --------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_HOST_HOST_H
 #define LLDB_HOST_HOST_H
 
 #include "lldb/Host/File.h"
 #include "lldb/Host/HostThread.h"
+#include "lldb/Utility/Environment.h"
 #include "lldb/Utility/FileSpec.h"
-#include "lldb/Utility/StringList.h"
 #include "lldb/lldb-private-forward.h"
 #include "lldb/lldb-private.h"
 #include <cerrno>
 #include <map>
 #include <stdarg.h>
 #include <string>
 #include <type_traits>
 
static Status RunShellCommand(
       std::string
           *command_output, // Pass NULL if you don't want the command output
       uint32_t timeout_sec,
       bool run_in_default_shell = true);
 
   static bool OpenFileInExternalEditor(const FileSpec &file_spec,
                                        uint32_t line_no);
 
-  static size_t GetEnvironment(StringList &env);
+  static Environment GetEnvironment();
 
   static std::unique_ptr<Connection>
   CreateDefaultConnection(llvm::StringRef url);
 };
 
 } // namespace lldb_private
 
 namespace llvm {

lldb/trunk/include/lldb/Interpreter/Args.h

 #include <string>
 #include <utility>
 #include <vector>
 
 // Other libraries and framework includes
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 // Project includes
+#include "lldb/Utility/Environment.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private-types.h"
 #include "lldb/lldb-types.h"
 
 namespace lldb_private {
 
 struct Option;
 
public:
 
   Args &operator=(const Args &rhs);
 
   //------------------------------------------------------------------
   /// Destructor.
   //------------------------------------------------------------------
   ~Args();
 
+  explicit Args(const Environment &env) : Args() {
+    SetArguments(const_cast<const char **>(env.getEnvp().get()));
+  }
+
+  explicit operator Environment() const { return GetConstArgumentVector(); }
+
   //------------------------------------------------------------------
   /// Dump all entries to the stream \a s using label \a label_name.
   ///
   /// If label_name is nullptr, the dump operation is skipped.
   ///
   /// @param[in] s
   ///     The stream to which to dump all arguments in the argument
   ///     vector.
public:
   // printable and isn't one of the common in escape sequences listed in the
   // help for EncodeEscapeSequences, then it will be encoded as octal. Printable
   // characters are left alone.
   static void ExpandEscapedCharacters(const char *src, std::string &dst);
 
   static std::string EscapeLLDBCommandArgument(const std::string &arg,
                                                char quote_char);
 
-  //------------------------------------------------------------------
-  /// Add or replace an environment variable with the given value.
-  ///
-  /// This command adds the environment variable if it is not already
-  /// present using the given value.  If the environment variable is
-  /// already in the list, it replaces the first such occurrence
-  /// with the new value.
-  //------------------------------------------------------------------
-  void AddOrReplaceEnvironmentVariable(llvm::StringRef env_var_name,
-                                       llvm::StringRef new_value);
-
-  /// Return whether a given environment variable exists.
-  ///
-  /// This command treats Args like a list of environment variables,
-  /// as used in ProcessLaunchInfo.  It treats each argument as
-  /// an {env_var_name}={value} or an {env_var_name} entry.
-  ///
-  /// @param[in] env_var_name
-  ///     Specifies the name of the environment variable to check.
-  ///
-  /// @param[out] argument_index
-  ///     If non-null, then when the environment variable is found,
-  ///     the index of the argument position will be returned in
-  ///     the size_t pointed to by this argument.
-  ///
-  /// @return
-  ///     true if the specified env var name exists in the list in
-  ///     either of the above-mentioned formats; otherwise, false.
-  //------------------------------------------------------------------
-  bool ContainsEnvironmentVariable(llvm::StringRef env_var_name,
-                                   size_t *argument_index = nullptr) const;
-
 private:
   size_t FindArgumentIndexForOption(Option *long_options,
                                     int long_options_index) const;
 
   std::vector<ArgEntry> m_entries;
   std::vector<char *> m_argv;
 
   void UpdateArgsAfterOptionParsing();
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_Command_h_

lldb/trunk/include/lldb/Target/Platform.h

public:
   ///     platform working directory will be prepended to the relative
   ///     directory.
   ///
   /// @return
   ///     An error object that describes anything that went wrong.
   //----------------------------------------------------------------------
   virtual Status Install(const FileSpec &src, const FileSpec &dst);
 
-  virtual size_t GetEnvironment(StringList &environment);
+  virtual Environment GetEnvironment();
 
   virtual bool GetFileExists(const lldb_private::FileSpec &file_spec);
 
   virtual Status Unlink(const FileSpec &file_spec);
 
   virtual MmapArgList GetMmapArgumentList(const ArchSpec &arch,
                                           lldb::addr_t addr,
                                           lldb::addr_t length,

lldb/trunk/include/lldb/Target/ProcessInfo.h

 //===-- ProcessInfo.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_ProcessInfo_h_
 #define liblldb_ProcessInfo_h_
 
 // LLDB headers
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Utility/ArchSpec.h"
+#include "lldb/Utility/Environment.h"
 #include "lldb/Utility/FileSpec.h"
 
 namespace lldb_private {
 //----------------------------------------------------------------------
 // ProcessInfo
 //
 // A base class for information for a process. This can be used to fill
 // out information for a process prior to launching it, or it can be
public:
   llvm::StringRef GetArg0() const;
 
   void SetArg0(llvm::StringRef arg);
 
   void SetArguments(const Args &args, bool first_arg_is_executable);
 
   void SetArguments(char const **argv, bool first_arg_is_executable);
 
-  Args &GetEnvironmentEntries() { return m_environment; }
-
-  const Args &GetEnvironmentEntries() const { return m_environment; }
+  Environment &GetEnvironment() { return m_environment; }
+  const Environment &GetEnvironment() const { return m_environment; }
 
 protected:
   FileSpec m_executable;
   std::string m_arg0; // argv[0] if supported. If empty, then use m_executable.
   // Not all process plug-ins support specifying an argv[0]
   // that differs from the resolved platform executable
   // (which is in m_executable)
   Args m_arguments; // All program arguments except argv[0]
-  Args m_environment;
+  Environment m_environment;
   uint32_t m_uid;
   uint32_t m_gid;
   ArchSpec m_arch;
   lldb::pid_t m_pid;
 };
 }
 
 #endif // #ifndef liblldb_ProcessInfo_h_

lldb/trunk/include/lldb/Target/Target.h

public:
   llvm::StringRef GetArg0() const;
 
   void SetArg0(llvm::StringRef arg);
 
   bool GetRunArguments(Args &args) const;
 
   void SetRunArguments(const Args &args);
 
-  size_t GetEnvironmentAsArgs(Args &env) const;
-
-  void SetEnvironmentFromArgs(const Args &env);
+  Environment GetEnvironment() const;
+  void SetEnvironment(Environment env);
 
   bool GetSkipPrologue() const;
 
   PathMappingList &GetSourcePathMap() const;
 
   FileSpecList &GetExecutableSearchPaths();
 
   FileSpecList &GetDebugFileSearchPaths();

lldb/trunk/include/lldb/Utility/Environment.h

+//===-- Environment.h -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_UTILITY_ENVIRONMENT_H
+#define LLDB_UTILITY_ENVIRONMENT_H
+
+#include "llvm/ADT/StringMap.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/FormatProviders.h"
+
+namespace lldb_private {
+
+class Environment : private llvm::StringMap<std::string> {
+  using Base = llvm::StringMap<std::string>;
+
+public:
+  class Envp {
+  public:
+    Envp(Envp &&RHS) = default;
+    Envp &operator=(Envp &&RHS) = default;
+
+    char *const *get() const { return Data; }
+    operator char *const *() const { return get(); }
+
+  private:
+    explicit Envp(const Environment &Env);
+    char *make_entry(llvm::StringRef Key, llvm::StringRef Value);
+    Envp(const Envp &) = delete;
+    Envp &operator=(const Envp &) = delete;
+    friend class Environment;
+
+    llvm::BumpPtrAllocator Allocator;
+    char **Data;
+  };
+
+  using Base::const_iterator;
+  using Base::iterator;
+  using Base::value_type;
+
+  using Base::begin;
+  using Base::clear;
+  using Base::count;
+  using Base::end;
+  using Base::erase;
+  using Base::find;
+  using Base::insert;
+  using Base::lookup;
+  using Base::size;
+  using Base::try_emplace;
+  using Base::operator[];
+
+  Environment() : Base() {}
+  Environment(const Environment &RHS) : Base(RHS) {}
+  Environment(Environment &&RHS) : Base(std::move(RHS)) {}
+  Environment(char *const *Env)
+      : Environment(const_cast<const char *const *>(Env)) {}
+  Environment(const char *const *Env);
+
+  Environment &operator=(Environment RHS) {
+    Base::operator=(std::move(RHS));
+    return *this;
+  }
+
+  std::pair<iterator, bool> insert(llvm::StringRef KeyEqValue) {
+    return insert(KeyEqValue.split('='));
+  }
+
+  void insert(const_iterator first, const_iterator last);
+
+  Envp getEnvp() const { return Envp(*this); }
+
+  static std::string compose(const value_type &KeyValue) {
+    return (KeyValue.first() + "=" + KeyValue.second).str();
+  }
+};
+
+} // namespace lldb_private
+
+namespace llvm {
+template <> struct format_provider<lldb_private::Environment> {
+  static void format(const lldb_private::Environment &Env, raw_ostream &Stream,
+                     StringRef Style) {
+    for (const auto &KV : Env)
+      Stream << "env[" << KV.first() << "] = " << KV.second << "\n";
+  }
+};
+} // namespace llvm
+
+#endif // #ifndef LLDB_UTILITY_ENVIRONMENT_H

lldb/trunk/packages/Python/lldbsuite/test/python_api/sblaunchinfo/TestSBLaunchInfo.py

+"""
+Test SBLaunchInfo
+"""
+
+from __future__ import print_function
+
+
+from lldbsuite.test.lldbtest import *
+
+
+def lookup(info, key):
+    for i in range(info.GetNumEnvironmentEntries()):
+        KeyEqValue = info.GetEnvironmentEntryAtIndex(i)
+        Key, Value = KeyEqValue.split("=")
+        if Key == key:
+            return Value
+    return ""
+
+class TestSBLaunchInfo(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    def test_environment_getset(self):
+        info = lldb.SBLaunchInfo(None)
+        info.SetEnvironmentEntries(["FOO=BAR"], False)
+        self.assertEquals(1, info.GetNumEnvironmentEntries())
+        info.SetEnvironmentEntries(["BAR=BAZ"], True)
+        self.assertEquals(2, info.GetNumEnvironmentEntries())
+        self.assertEquals("BAR", lookup(info, "FOO"))
+        self.assertEquals("BAZ", lookup(info, "BAR"))

lldb/trunk/source/API/SBLaunchInfo.cpp

 
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+class lldb_private::SBLaunchInfoImpl : public ProcessLaunchInfo {
+public:
+  SBLaunchInfoImpl()
+      : ProcessLaunchInfo(), m_envp(GetEnvironment().getEnvp()) {}
+
+  const char *const *GetEnvp() const { return m_envp; }
+  void RegenerateEnvp() { m_envp = GetEnvironment().getEnvp(); }
+
+  SBLaunchInfoImpl &operator=(const ProcessLaunchInfo &rhs) {
+    ProcessLaunchInfo::operator=(rhs);
+    RegenerateEnvp();
+    return *this;
+  }
+
+private:
+  Environment::Envp m_envp;
+};
+
 SBLaunchInfo::SBLaunchInfo(const char **argv)
-    : m_opaque_sp(new ProcessLaunchInfo()) {
+    : m_opaque_sp(new SBLaunchInfoImpl()) {
   m_opaque_sp->GetFlags().Reset(eLaunchFlagDebug | eLaunchFlagDisableASLR);
   if (argv && argv[0])
     m_opaque_sp->GetArguments().SetArguments(argv);
 }
 
 SBLaunchInfo::~SBLaunchInfo() {}
 
-lldb_private::ProcessLaunchInfo &SBLaunchInfo::ref() { return *m_opaque_sp; }
-
 const lldb_private::ProcessLaunchInfo &SBLaunchInfo::ref() const {
   return *m_opaque_sp;
 }
 
+void SBLaunchInfo::set_ref(const ProcessLaunchInfo &info) {
+  *m_opaque_sp = info;
+}
+
 lldb::pid_t SBLaunchInfo::GetProcessID() { return m_opaque_sp->GetProcessID(); }
 
 uint32_t SBLaunchInfo::GetUserID() { return m_opaque_sp->GetUserID(); }
 
 uint32_t SBLaunchInfo::GetGroupID() { return m_opaque_sp->GetGroupID(); }
 
 bool SBLaunchInfo::UserIDIsValid() { return m_opaque_sp->UserIDIsValid(); }
 
if (append) {
     if (argv)
       m_opaque_sp->GetArguments().SetArguments(argv);
     else
       m_opaque_sp->GetArguments().Clear();
   }
 }
 
 uint32_t SBLaunchInfo::GetNumEnvironmentEntries() {
-  return m_opaque_sp->GetEnvironmentEntries().GetArgumentCount();
+  return m_opaque_sp->GetEnvironment().size();
 }
 
 const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
-  return m_opaque_sp->GetEnvironmentEntries().GetArgumentAtIndex(idx);
+  if (idx > GetNumEnvironmentEntries())
+    return nullptr;
+  return m_opaque_sp->GetEnvp()[idx];
 }
 
 void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
-  if (append) {
-    if (envp)
-      m_opaque_sp->GetEnvironmentEntries().AppendArguments(envp);
-  } else {
-    if (envp)
-      m_opaque_sp->GetEnvironmentEntries().SetArguments(envp);
-    else
-      m_opaque_sp->GetEnvironmentEntries().Clear();
-  }
+  Environment env(envp);
+  if (append)
+    m_opaque_sp->GetEnvironment().insert(env.begin(), env.end());
+    m_opaque_sp->GetEnvironment() = env;
+  m_opaque_sp->RegenerateEnvp();
 }
 
 void SBLaunchInfo::Clear() { m_opaque_sp->Clear(); }
 
 const char *SBLaunchInfo::GetWorkingDirectory() const {
   return m_opaque_sp->GetWorkingDirectory().GetCString();
 }
 

lldb/trunk/source/API/SBPlatform.cpp

return platform_sp->RunShellCommand(
         &shell_command.m_opaque_ptr->m_signo,
         &shell_command.m_opaque_ptr->m_output,
         shell_command.m_opaque_ptr->m_timeout_sec);
   });
 }
 
 SBError SBPlatform::Launch(SBLaunchInfo &launch_info) {
   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
-    return platform_sp->LaunchProcess(launch_info.ref());
+    ProcessLaunchInfo info = launch_info.ref();
+    Status error = platform_sp->LaunchProcess(info);
+    launch_info.set_ref(info);
+    return error;
   });
 }
 
 SBError SBPlatform::Kill(const lldb::pid_t pid) {
   return ExecuteConnected([&](const lldb::PlatformSP &platform_sp) {
     return platform_sp->KillProcess(pid);
   });
 }

lldb/trunk/source/API/SBProcess.cpp

if (process_sp->GetState() == eStateConnected) {
           FileSpec{stderr_path, false}, FileSpec{working_directory, false},
           launch_flags);
       Module *exe_module = process_sp->GetTarget().GetExecutableModulePointer();
       if (exe_module)
         launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
       if (argv)
         launch_info.GetArguments().AppendArguments(argv);
       if (envp)
-        launch_info.GetEnvironmentEntries().SetArguments(envp);
+        launch_info.GetEnvironment() = Environment(envp);
       error.SetError(process_sp->Launch(launch_info));
     } else {
       error.SetErrorString("must be in eStateConnected to call RemoteLaunch");
     }
   } else {
     error.SetErrorString("unable to attach pid");
   }
 

lldb/trunk/source/API/SBTarget.cpp

ProcessLaunchInfo launch_info(
         launch_flags);
 
     Module *exe_module = target_sp->GetExecutableModulePointer();
     if (exe_module)
       launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
     if (argv)
       launch_info.GetArguments().AppendArguments(argv);
     if (envp)
-      launch_info.GetEnvironmentEntries().SetArguments(envp);
+      launch_info.GetEnvironment() = Environment(envp);
 
     if (listener.IsValid())
       launch_info.SetListener(listener.GetSP());
 
     error.SetError(target_sp->Launch(launch_info, NULL));
 
     sb_process.SetSP(target_sp->GetProcessSP());
   } else {
StateType state = eStateInvalid;
             error.SetErrorString("process attach is in progress");
           else
             error.SetErrorString("a process is already being debugged");
           return sb_process;
         }
       }
     }
 
-    lldb_private::ProcessLaunchInfo &launch_info = sb_launch_info.ref();
+    lldb_private::ProcessLaunchInfo launch_info = sb_launch_info.ref();
 
     if (!launch_info.GetExecutableFile()) {
       Module *exe_module = target_sp->GetExecutableModulePointer();
       if (exe_module)
         launch_info.SetExecutableFile(exe_module->GetPlatformFileSpec(), true);
     }
 
     const ArchSpec &arch_spec = target_sp->GetArchitecture();
     if (arch_spec.IsValid())
       launch_info.GetArchitecture() = arch_spec;
 
     error.SetError(target_sp->Launch(launch_info, NULL));
+    sb_launch_info.set_ref(launch_info);
     sb_process.SetSP(target_sp->GetProcessSP());
   } else {
     error.SetErrorString("SBTarget is invalid");
   }
 
   log = lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API);
   if (log)
     log->Printf("SBTarget(%p)::Launch (...) => SBProcess(%p)",
lldb::addr_t SBTarget::GetStackRedZoneSize() {
   }
   return 0;
 }
 
 lldb::SBLaunchInfo SBTarget::GetLaunchInfo() const {
   lldb::SBLaunchInfo launch_info(NULL);
   TargetSP target_sp(GetSP());
   if (target_sp)
-    launch_info.ref() = m_opaque_sp->GetProcessLaunchInfo();
+    launch_info.set_ref(m_opaque_sp->GetProcessLaunchInfo());
   return launch_info;
 }
 
 void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
   TargetSP target_sp(GetSP());
   if (target_sp)
     m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());
 }

lldb/trunk/source/Commands/CommandObjectProcess.cpp

else
       m_options.launch_info.GetFlags().Clear(eLaunchFlagDisableASLR);
 
     if (target->GetDetachOnError())
       m_options.launch_info.GetFlags().Set(eLaunchFlagDetachOnError);
 
     if (target->GetDisableSTDIO())
       m_options.launch_info.GetFlags().Set(eLaunchFlagDisableSTDIO);
 
-    Args environment;
-    target->GetEnvironmentAsArgs(environment);
-    if (environment.GetArgumentCount() > 0)
-      m_options.launch_info.GetEnvironmentEntries().AppendArguments(
-          environment);
+    m_options.launch_info.GetEnvironment() = target->GetEnvironment();
 
     if (!target_settings_argv0.empty()) {
       m_options.launch_info.GetArguments().AppendArgument(
           target_settings_argv0);
       m_options.launch_info.SetExecutableFile(
           exe_module_sp->GetPlatformFileSpec(), false);
     } else {
       m_options.launch_info.SetExecutableFile(

lldb/trunk/source/Host/freebsd/Host.cpp

if (GetFreeBSDProcessArgs(NULL, process_info)) {
     GetFreeBSDProcessUserAndGroup(process_info);
     return true;
   }
 
   process_info.Clear();
   return false;
 }
 
-size_t Host::GetEnvironment(StringList &env) {
-  char **host_env = environ;
-  char *env_entry;
-  size_t i;
-  for (i = 0; (env_entry = host_env[i]) != NULL; ++i)
-    env.AppendString(env_entry);
-  return i;
-}
+Environment Host::GetEnvironment() { return Environment(environ); }
 
 Status Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
   return Status("unimplemented");
 }

lldb/trunk/source/Host/linux/Host.cpp

static bool GetProcessAndStatInfo(::pid_t pid,
   process_info.SetProcessID(pid);
   process_info.GetExecutableFile().SetFile(PathRef, false);
   process_info.GetArchitecture().MergeFrom(HostInfo::GetArchitecture());
 
   llvm::StringRef Rest = Environ->getBuffer();
   while (!Rest.empty()) {
     llvm::StringRef Var;
     std::tie(Var, Rest) = Rest.split('\0');
-    process_info.GetEnvironmentEntries().AppendArgument(Var);
+    process_info.GetEnvironment().insert(Var);
   }
 
   llvm::StringRef Arg0;
   std::tie(Arg0, Rest) = Cmdline->getBuffer().split('\0');
   process_info.SetArg0(Arg0);
   while (!Rest.empty()) {
     llvm::StringRef Arg;
     std::tie(Arg, Rest) = Rest.split('\0');

 }
 
 bool Host::GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &process_info) {
   ::pid_t tracerpid;
   ProcessState State;
   return GetProcessAndStatInfo(pid, process_info, State, tracerpid);
 }
 
-size_t Host::GetEnvironment(StringList &env) {
-  char **host_env = environ;
-  char *env_entry;
-  size_t i;
-  for (i = 0; (env_entry = host_env[i]) != NULL; ++i)
-    env.AppendString(env_entry);
-  return i;
-}
+Environment Host::GetEnvironment() { return Environment(environ); }
 
 Status Host::ShellExpandArguments(ProcessLaunchInfo &launch_info) {
   return Status("unimplemented");
 }

lldb/trunk/source/Host/macosx/Host.mm

else {
     if (getcwd(cwd, PATH_MAX))
       command.Printf(" --working-dir '%s'", cwd);
   }
 
   if (launch_info.GetFlags().Test(eLaunchFlagDisableASLR))
     command.PutCString(" --disable-aslr");
 
   // We are launching on this host in a terminal. So compare the environment on
-  // the host
-  // to what is supplied in the launch_info. Any items that aren't in the host
-  // environment
-  // need to be sent to darwin-debug. If we send all environment entries, we
-  // might blow the
-  // max command line length, so we only send user modified entries.
-  const char **envp =
-      launch_info.GetEnvironmentEntries().GetConstArgumentVector();
-
-  StringList host_env;
-  const size_t host_env_count = Host::GetEnvironment(host_env);
-
-  if (envp && envp[0]) {
-    const char *env_entry;
-    for (size_t env_idx = 0; (env_entry = envp[env_idx]) != NULL; ++env_idx) {
-      bool add_entry = true;
-      for (size_t i = 0; i < host_env_count; ++i) {
-        const char *host_env_entry = host_env.GetStringAtIndex(i);
-        if (strcmp(env_entry, host_env_entry) == 0) {
-          add_entry = false;
-          break;
-        }
-      }
-      if (add_entry) {
-        command.Printf(" --env='%s'", env_entry);
-      }
-    }
+  // the host to what is supplied in the launch_info. Any items that aren't in
+  // the host environment need to be sent to darwin-debug. If we send all
+  // environment entries, we might blow the max command line length, so we only
+  // send user modified entries.
+  Environment host_env = Host::GetEnvironment();
+
+  for (const auto &KV : launch_info.GetEnvironment()) {
+    auto host_entry = host_env.find(KV.first());
+    if (host_entry == host_env.end() || host_entry->second != KV.second)
+      command.Format(" --env='{0}'", Environment::compose(KV));
   }
 
   command.PutCString(" -- ");
 
   const char **argv = launch_info.GetArguments().GetConstArgumentVector();
   if (argv) {
     for (size_t i = 0; argv[i] != NULL; ++i) {
       if (i == 0)
if (error != noErr) {
 
     return false;
   }
 
   return true;
 #endif // #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
 }
 
-size_t Host::GetEnvironment(StringList &env) {
-  char **host_env = *_NSGetEnviron();
-  char *env_entry;
-  size_t i;
-  for (i = 0; (env_entry = host_env[i]) != NULL; ++i)
-    env.AppendString(env_entry);
-  return i;
-}
+Environment Host::GetEnvironment() { return Environment(*_NSGetEnviron()); }
 
 static bool GetMacOSXProcessCPUType(ProcessInstanceInfo &process_info) {
   if (process_info.ProcessIDIsValid()) {
     // Make a new mib to stay thread safe
     int mib[CTL_MAXNAME] = {
         0,
     };
     size_t mib_len = CTL_MAXNAME;
if (::sysctl(proc_args_mib, 3, arg_data.GetBytes(), &arg_data_size, NULL,
           // Now extract all arguments
           Args &proc_args = process_info.GetArguments();
           for (int i = 0; i < static_cast<int>(argc); ++i) {
             cstr = data.GetCStr(&offset);
             if (cstr)
               proc_args.AppendArgument(llvm::StringRef(cstr));
           }
 
-          Args &proc_env = process_info.GetEnvironmentEntries();
+          Environment &proc_env = process_info.GetEnvironment();
           while ((cstr = data.GetCStr(&offset))) {
             if (cstr[0] == '\0')
               break;
 
             if (check_for_ios_simulator) {
               if (strncmp(cstr, "SIMULATOR_UDID=", strlen("SIMULATOR_UDID=")) ==
                   0)
                 process_info.GetArchitecture().GetTriple().setOS(
                     llvm::Triple::IOS);
               else
                 process_info.GetArchitecture().GetTriple().setOS(
                     llvm::Triple::MacOSX);
             }
 
-            proc_env.AppendArgument(llvm::StringRef(cstr));
+            proc_env.insert(cstr);
           }
           return true;
         }
       }
     }
   }
   return false;
 }
static void PackageXPCArguments(xpc_object_t message, const char *prefix,
   xpc_dictionary_set_int64(message, buf, count);
   for (size_t i = 0; i < count; i++) {
     memset(buf, 0, 50);
     sprintf(buf, "%s%zi", prefix, i);
     xpc_dictionary_set_string(message, buf, args.GetArgumentAtIndex(i));
   }
 }
 
+static void PackageXPCEnvironment(xpc_object_t message, llvm::StringRef prefix,
+                                  const Environment &env) {
+  xpc_dictionary_set_int64(message, (prefix + "Count").str().c_str(),
+                           env.size());
+  size_t i = 0;
+  for (const auto &KV : env) {
+    xpc_dictionary_set_string(message, (prefix + llvm::Twine(i)).str().c_str(),
+                              Environment::compose(KV).c_str());
+  }
+}
+
 /*
  A valid authorizationRef means that
     - there is the LaunchUsingXPCRightName rights in the /etc/authorization
     - we have successfully copied the rights to be send over the XPC wire
  Once obtained, it will be valid for as long as the process lives.
  */
 static AuthorizationRef authorizationRef = NULL;
 static Status getXPCAuthorization(ProcessLaunchInfo &launch_info) {
#if !NO_XPC_SERVICES
 
   if (send_auth) {
     xpc_dictionary_set_data(message, LauncherXPCServiceAuthKey, extForm.bytes,
                             sizeof(AuthorizationExternalForm));
   }
 
   PackageXPCArguments(message, LauncherXPCServiceArgPrefxKey,
                       launch_info.GetArguments());
-  PackageXPCArguments(message, LauncherXPCServiceEnvPrefxKey,
-                      launch_info.GetEnvironmentEntries());
+  PackageXPCEnvironment(message, LauncherXPCServiceEnvPrefxKey,
+                        launch_info.GetEnvironment());
 
   // Posix spawn stuff.
   xpc_dictionary_set_int64(message, LauncherXPCServiceCPUTypeKey,
                            launch_info.GetArchitecture().GetMachOCPUType());
   xpc_dictionary_set_int64(message, LauncherXPCServicePosixspawnFlagsKey,
                            GetPosixspawnFlags(launch_info));
   const FileAction *file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
   if (file_action && !file_action->GetPath().empty()) {
if (cpu != 0 && cpu != static_cast<cpu_type_t>(UINT32_MAX) &&
         return error;
     }
   }
 #endif // !defined(__arm__)
 
   const char *tmp_argv[2];
   char *const *argv = const_cast<char *const *>(
       launch_info.GetArguments().GetConstArgumentVector());
-  char *const *envp = const_cast<char *const *>(
-      launch_info.GetEnvironmentEntries().GetConstArgumentVector());
+  Environment::Envp envp = launch_info.GetEnvironment().getEnvp();
   if (argv == NULL) {
     // posix_spawn gets very unhappy if it doesn't have at least the program
     // name in argv[0]. One of the side affects I have noticed is the
     // environment
     // variables don't make it into the child process if "argv == NULL"!!!
     tmp_argv[0] = exe_path;
     tmp_argv[1] = NULL;
     argv = const_cast<char *const *>(tmp_argv);
error.SetError(
         ::posix_spawnp(&result_pid, exe_path, &file_actions, &attr, argv, envp),
         eErrorTypePOSIX);
 
     if (error.Fail()) {
       LLDB_LOG(log,
                "error: {0}, ::posix_spawnp(pid => {1}, path = '{2}', "
                "file_actions = {3}, "
                "attr = {4}, argv = {5}, envp = {6} )",
-               error, result_pid, exe_path, &file_actions, &attr, argv, envp);
+               error, result_pid, exe_path, &file_actions, &attr, argv,
+               envp.get());
       if (log) {
         for (int ii = 0; argv[ii]; ++ii)
           LLDB_LOG(log, "argv[{0}] = '{1}'", ii, argv[ii]);
       }
     }
 
   } else {
     error.SetError(
         ::posix_spawnp(&result_pid, exe_path, NULL, &attr, argv, envp),
         eErrorTypePOSIX);
 
     if (error.Fail()) {
       LLDB_LOG(log,
                "error: {0}, ::posix_spawnp ( pid => {1}, path = '{2}', "
                "file_actions = NULL, attr = {3}, argv = {4}, envp = {5} )",
-               error, result_pid, exe_path, &attr, argv, envp);
+               error, result_pid, exe_path, &attr, argv, envp.get());
       if (log) {
         for (int ii = 0; argv[ii]; ++ii)
           LLDB_LOG(log, "argv[{0}] = '{1}'", ii, argv[ii]);
       }
     }
   }
   pid = result_pid;
 

lldb/trunk/source/Host/netbsd/Host.cpp

 
 extern "C" {
 extern char **environ;
 }
 
 using namespace lldb;
 using namespace lldb_private;
 
-size_t Host::GetEnvironment(StringList &env) {
-  char **host_env = environ;
-  char *env_entry;
-  size_t i;
-  for (i = 0; (env_entry = host_env[i]) != NULL; ++i)
-    env.AppendString(env_entry);
-  return i;
-}
+Environment Host::GetEnvironment() { return Environment(environ); }
 
 static bool GetNetBSDProcessArgs(const ProcessInstanceInfoMatch *match_info_ptr,
                                  ProcessInstanceInfo &process_info) {
   if (!process_info.ProcessIDIsValid())
     return false;
 
   int pid = process_info.GetProcessID();
 

lldb/trunk/source/Host/openbsd/Host.cpp

 
 extern "C" {
 extern char **environ;
 }
 
 using namespace lldb;
 using namespace lldb_private;
 
-size_t Host::GetEnvironment(StringList &env) {
+Environment Host::GetEnvironment() {
+  Environment env;
   char *v;
   char **var = environ;
   for (; var != NULL && *var != NULL; ++var) {
     v = strchr(*var, (int)'-');
     if (v == NULL)
       continue;
-    env.AppendString(v);
+    env.insert(v);
   }
-  return env.GetSize();
+  return env;
 }
 
 static bool
 GetOpenBSDProcessArgs(const ProcessInstanceInfoMatch *match_info_ptr,
                       ProcessInstanceInfo &process_info) {
   if (process_info.ProcessIDIsValid()) {
     int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_ARGS,
                   (int)process_info.GetProcessID()};

lldb/trunk/source/Host/posix/ProcessLauncherPosixFork.cpp

 #include <linux/personality.h>
 #elif defined(__linux__)
 #include <sys/personality.h>
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
-static void FixupEnvironment(Args &env) {
+static void FixupEnvironment(Environment &env) {
 #ifdef __ANDROID__
   // If there is no PATH variable specified inside the environment then set the
   // path to /system/bin. It is required because the default path used by
   // execve() is wrong on android.
-  static const char *path = "PATH=";
-  for (auto &entry : env.entries()) {
-    if (entry.ref.startswith(path))
-      return;
-  }
-  env.AppendArgument(llvm::StringRef("PATH=/system/bin"));
+  env.try_emplace("PATH", "/system/bin");
 #endif
 }
 
 static void LLVM_ATTRIBUTE_NORETURN ExitWithError(int error_fd,
                                                   const char *operation) {
   int err = errno;
   llvm::raw_fd_ostream os(error_fd, true);
   os << operation << " failed: " << llvm::sys::StrError(err);
static void LLVM_ATTRIBUTE_NORETURN ChildFunc(int error_fd,
   const char **argv = info.GetArguments().GetConstArgumentVector();
 
   // Change working directory
   if (info.GetWorkingDirectory() &&
       0 != ::chdir(info.GetWorkingDirectory().GetCString()))
     ExitWithError(error_fd, "chdir");
 
   DisableASLRIfRequested(error_fd, info);
-  Args env = info.GetEnvironmentEntries();
+  Environment env = info.GetEnvironment();
   FixupEnvironment(env);
-  const char **envp = env.GetConstArgumentVector();
+  Environment::Envp envp = env.getEnvp();
 
   // Clear the signal mask to prevent the child from being affected by
   // any masking done by the parent.
   sigset_t set;
   if (sigemptyset(&set) != 0 ||
       pthread_sigmask(SIG_SETMASK, &set, nullptr) != 0)
     ExitWithError(error_fd, "pthread_sigmask");
 
   if (info.GetFlags().Test(eLaunchFlagDebug)) {
     // HACK:
     // Close everything besides stdin, stdout, and stderr that has no file
     // action to avoid leaking. Only do this when debugging, as elsewhere we
     // actually rely on
     // passing open descriptors to child processes.
     for (int fd = 3; fd < sysconf(_SC_OPEN_MAX); ++fd)
       if (!info.GetFileActionForFD(fd) && fd != error_fd)
         close(fd);
 
     // Start tracing this child that is about to exec.
     if (ptrace(PT_TRACE_ME, 0, nullptr, 0) == -1)
       ExitWithError(error_fd, "ptrace");
   }
 
   // Execute.  We should never return...
-  execve(argv[0], const_cast<char *const *>(argv),
-         const_cast<char *const *>(envp));
+  execve(argv[0], const_cast<char *const *>(argv), envp);
 
 #if defined(__linux__)
   if (errno == ETXTBSY) {
     // On android M and earlier we can get this error because the adb deamon can
     // hold a write
     // handle on the executable even after it has finished uploading it. This
     // state lasts
     // only a short time and happens only when there are many concurrent adb
     // commands being
     // issued, such as when running the test suite. (The file remains open when
     // someone does
     // an "adb shell" command in the fork() child before it has had a chance to
     // exec.) Since
     // this state should clear up quickly, wait a while and then give it one
     // more go.
     usleep(50000);
-    execve(argv[0], const_cast<char *const *>(argv),
-           const_cast<char *const *>(envp));
+    execve(argv[0], const_cast<char *const *>(argv), envp);
   }
 #endif
 
   // ...unless exec fails.  In which case we definitely need to end the child
   // here.
   ExitWithError(error_fd, "execve");
 }
 

lldb/trunk/source/Host/windows/Host.cpp

for (size_t i = 0; i < args_array_sp->GetSize(); i++) {
 
       launch_info.GetArguments().AppendArgument(str_sp->GetValue());
     }
   }
 
   return error;
 }
 
-size_t Host::GetEnvironment(StringList &env) {
+Environment Host::GetEnvironment() {
+  Environment env;
   // The environment block on Windows is a contiguous buffer of NULL terminated
-  // strings,
-  // where the end of the environment block is indicated by two consecutive
-  // NULLs.
+  // strings, where the end of the environment block is indicated by two
+  // consecutive NULLs.
   LPWCH environment_block = ::GetEnvironmentStringsW();
-  env.Clear();
   while (*environment_block != L'\0') {
     std::string current_var;
     auto current_var_size = wcslen(environment_block) + 1;
     if (!llvm::convertWideToUTF8(environment_block, current_var)) {
       environment_block += current_var_size;
       continue;
     }
     if (current_var[0] != '=')
-      env.AppendString(current_var);
+      env.insert(current_var);
 
     environment_block += current_var_size;
   }
-  return env.GetSize();
+  return env;
 }

lldb/trunk/source/Interpreter/Args.cpp

uint32_t result = llvm::StringSwitch<uint32_t>(s)
                         .Case("arg5", LLDB_REGNUM_GENERIC_ARG5)
                         .Case("arg6", LLDB_REGNUM_GENERIC_ARG6)
                         .Case("arg7", LLDB_REGNUM_GENERIC_ARG7)
                         .Case("arg8", LLDB_REGNUM_GENERIC_ARG8)
                         .Default(LLDB_INVALID_REGNUM);
   return result;
 }
 
-void Args::AddOrReplaceEnvironmentVariable(llvm::StringRef env_var_name,
-                                           llvm::StringRef new_value) {
-  if (env_var_name.empty())
-    return;
-
-  // Build the new entry.
-  std::string var_string(env_var_name);
-  if (!new_value.empty()) {
-    var_string += "=";
-    var_string += new_value;
-  }
-
-  size_t index = 0;
-  if (ContainsEnvironmentVariable(env_var_name, &index)) {
-    ReplaceArgumentAtIndex(index, var_string);
-    return;
-  }
-
-  // We didn't find it.  Append it instead.
-  AppendArgument(var_string);
-}
-
-bool Args::ContainsEnvironmentVariable(llvm::StringRef env_var_name,
-                                       size_t *argument_index) const {
-  // Validate args.
-  if (env_var_name.empty())
-    return false;
-
-  // Check each arg to see if it matches the env var name.
-  for (auto arg : llvm::enumerate(m_entries)) {
-    llvm::StringRef name, value;
-    std::tie(name, value) = arg.value().ref.split('=');
-    if (name != env_var_name)
-      continue;
-
-    if (argument_index)
-      *argument_index = arg.index();
-    return true;
-  }
-
-  // We didn't find a match.
-  return false;
-}
-
 size_t Args::FindArgumentIndexForOption(Option *long_options,
                                         int long_options_index) const {
   char short_buffer[3];
   char long_buffer[255];
   ::snprintf(short_buffer, sizeof(short_buffer), "-%c",
              long_options[long_options_index].val);
   ::snprintf(long_buffer, sizeof(long_buffer), "--%s",
              long_options[long_options_index].definition->long_option);

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformDarwin.cpp

if (shell_name == NULL)
     shell_name = shell_string.c_str();
   else
     shell_name++;
 
   if (strcmp(shell_name, "sh") == 0) {
     // /bin/sh re-exec's itself as /bin/bash requiring another resume.
     // But it only does this if the COMMAND_MODE environment variable
     // is set to "legacy".
-    const char **envp =
-        launch_info.GetEnvironmentEntries().GetConstArgumentVector();
-    if (envp != NULL) {
-      for (int i = 0; envp[i] != NULL; i++) {
-        if (strcmp(envp[i], "COMMAND_MODE=legacy") == 0)
-          return 2;
-      }
-    }
+    if (launch_info.GetEnvironment().lookup("COMMAND_MODE") == "legacy")
     return 1;
   } else if (strcmp(shell_name, "csh") == 0 ||
              strcmp(shell_name, "tcsh") == 0 ||
              strcmp(shell_name, "zsh") == 0) {
     // csh and tcsh always seem to re-exec themselves.
     return 2;
   } else
     return 1;
ConstString PlatformDarwin::GetFullNameForDylib(ConstString basename) {
   return ConstString(stream.GetString());
 }
 
 bool PlatformDarwin::GetOSVersion(uint32_t &major, uint32_t &minor,
                                   uint32_t &update, Process *process) {
   if (process && strstr(GetPluginName().GetCString(), "-simulator")) {
     lldb_private::ProcessInstanceInfo proc_info;
     if (Host::GetProcessInfo(process->GetID(), proc_info)) {
-      Args &env = proc_info.GetEnvironmentEntries();
-      const size_t n = env.GetArgumentCount();
-      const llvm::StringRef k_runtime_version("SIMULATOR_RUNTIME_VERSION=");
-      const llvm::StringRef k_dyld_root_path("DYLD_ROOT_PATH=");
-      std::string dyld_root_path;
-
-      for (size_t i = 0; i < n; ++i) {
-        const char *env_cstr = env.GetArgumentAtIndex(i);
-        if (env_cstr) {
-          llvm::StringRef env_str(env_cstr);
-          if (env_str.consume_front(k_runtime_version)) {
-            if (Args::StringToVersion(env_str, major, minor, update))
-              return true;
-          } else if (env_str.consume_front(k_dyld_root_path)) {
-            dyld_root_path = env_str;
-          }
-        }
-      }
+      const Environment &env = proc_info.GetEnvironment();
+
+      if (Args::StringToVersion(env.lookup("SIMULATOR_RUNTIME_VERSION"), major,
+                                minor, update))
 
+      std::string dyld_root_path = env.lookup("DYLD_ROOT_PATH");
       if (!dyld_root_path.empty()) {
         dyld_root_path += "/System/Library/CoreServices/SystemVersion.plist";
         ApplePropertyList system_version_plist(dyld_root_path.c_str());
         std::string product_version;
         if (system_version_plist.GetValueAsString("ProductVersion",
                                                   product_version)) {
           return Args::StringToVersion(product_version, major, minor, update);
         }
PlatformDarwin::LaunchProcess(lldb_private::ProcessLaunchInfo &launch_info) {
   // Starting in Fall 2016 OSes, NSLog messages only get mirrored to stderr
   // if the OS_ACTIVITY_DT_MODE environment variable is set.  (It doesn't
   // require any specific value; rather, it just needs to exist).
   // We will set it here as long as the IDE_DISABLED_OS_ACTIVITY_DT_MODE flag
   // is not set.  Xcode makes use of IDE_DISABLED_OS_ACTIVITY_DT_MODE to tell
   // LLDB *not* to muck with the OS_ACTIVITY_DT_MODE flag when they
   // specifically want it unset.
   const char *disable_env_var = "IDE_DISABLED_OS_ACTIVITY_DT_MODE";
-  auto &env_vars = launch_info.GetEnvironmentEntries();
-  if (!env_vars.ContainsEnvironmentVariable(llvm::StringRef(disable_env_var))) {
+  auto &env_vars = launch_info.GetEnvironment();
+  if (!env_vars.count(disable_env_var)) {
     // We want to make sure that OS_ACTIVITY_DT_MODE is set so that
     // we get os_log and NSLog messages mirrored to the target process
     // stderr.
-    if (!env_vars.ContainsEnvironmentVariable(
-            llvm::StringRef("OS_ACTIVITY_DT_MODE")))
-      env_vars.AppendArgument(llvm::StringRef("OS_ACTIVITY_DT_MODE=enable"));
+    env_vars.try_emplace("OS_ACTIVITY_DT_MODE", "enable");
   }
 
   // Let our parent class do the real launching.
   return PlatformPOSIX::LaunchProcess(launch_info);
 }
 
 lldb_private::Status
 PlatformDarwin::FindBundleBinaryInExecSearchPaths (const ModuleSpec &module_spec, Process *process, 

lldb/trunk/source/Plugins/Platform/MacOSX/PlatformiOSSimulatorCoreSimulatorSupport.mm

if (launch_info.GetArguments().GetArgumentCount()) {
     for (size_t idx = 0; idx < args.GetArgumentCount(); idx++)
       [args_array
           addObject:[NSString
                         stringWithUTF8String:args.GetArgumentAtIndex(idx)]];
 
     [options setObject:args_array forKey:kSimDeviceSpawnArguments];
   }
 
-  if (launch_info.GetEnvironmentEntries().GetArgumentCount()) {
-    const Args &envs(launch_info.GetEnvironmentEntries());
-    NSMutableDictionary *env_dict = [[NSMutableDictionary alloc] init];
-    for (size_t idx = 0; idx < envs.GetArgumentCount(); idx++) {
-      llvm::StringRef arg_sr(envs.GetArgumentAtIndex(idx));
-      auto first_eq = arg_sr.find('=');
-      if (first_eq == llvm::StringRef::npos)
-        continue;
-      llvm::StringRef key = arg_sr.substr(0, first_eq);
-      llvm::StringRef value = arg_sr.substr(first_eq + 1);
 
-      NSString *key_ns = [NSString stringWithUTF8String:key.str().c_str()];
-      NSString *value_ns = [NSString stringWithUTF8String:value.str().c_str()];
+  for (const auto &KV : launch_info.GetEnvironment()) {
+    NSString *key_ns = [NSString stringWithUTF8String:KV.first().str().c_str()];
+    NSString *value_ns = [NSString stringWithUTF8String:KV.second.c_str()];
 
-      [env_dict setValue:value_ns forKey:key_ns];
-    }
 
-    [options setObject:env_dict forKey:kSimDeviceSpawnEnvironment];
-  }
 
   Status error;
   File stdin_file;
   File stdout_file;
   File stderr_file;
   error = HandleFileAction(launch_info, options, kSimDeviceSpawnStdin,
                            STDIN_FILENO, stdin_file);
 

lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.h

public:
   bool GetRemoteOSBuildString(std::string &s) override;
 
   bool GetRemoteOSKernelDescription(std::string &s) override;
 
   lldb_private::ArchSpec GetRemoteSystemArchitecture() override;
 
   const lldb::UnixSignalsSP &GetRemoteUnixSignals() override;
 
-  size_t GetEnvironment(lldb_private::StringList &environment) override;
+  lldb_private::Environment GetEnvironment() override;
 
   bool IsConnected() const override;
 
   lldb_private::Status RunShellCommand(
       const char *command,                       // Shouldn't be nullptr
       const lldb_private::FileSpec &working_dir, // Pass empty FileSpec to use
                                                  // the current working
                                                  // directory

lldb/trunk/source/Plugins/Platform/POSIX/PlatformPOSIX.cpp

 
 bool PlatformPOSIX::GetRemoteOSBuildString(std::string &s) {
   if (m_remote_platform_sp)
     return m_remote_platform_sp->GetRemoteOSBuildString(s);
   s.clear();
   return false;
 }
 
-size_t PlatformPOSIX::GetEnvironment(StringList &env) {
+Environment PlatformPOSIX::GetEnvironment() {
   if (IsRemote()) {
     if (m_remote_platform_sp)
-      return m_remote_platform_sp->GetEnvironment(env);
-    return 0;
+      return m_remote_platform_sp->GetEnvironment();
+    return Environment();
   }
-  return Host::GetEnvironment(env);
+  return Host::GetEnvironment();
 }
 
 bool PlatformPOSIX::GetRemoteOSKernelDescription(std::string &s) {
   if (m_remote_platform_sp)
     return m_remote_platform_sp->GetRemoteOSKernelDescription(s);
   s.clear();
   return false;
 }

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.h

public:
 
   bool GetSupportedArchitectureAtIndex(uint32_t idx,
                                        lldb_private::ArchSpec &arch) override;
 
   void GetStatus(lldb_private::Stream &strm) override;
 
   bool CanDebugProcess() override;
 
-  size_t GetEnvironment(StringList &env) override;
+  Environment GetEnvironment() override;
 
   // FIXME not sure what the _sigtramp equivalent would be on this platform
   void CalculateTrapHandlerSymbolNames() override {}
 
   ConstString GetFullNameForDylib(ConstString basename) override;
 
 protected:
   lldb::PlatformSP m_remote_platform_sp;
 
 private:
   DISALLOW_COPY_AND_ASSIGN(PlatformWindows);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_PlatformWindows_h_

lldb/trunk/source/Plugins/Platform/Windows/PlatformWindows.cpp

#ifdef _WIN32
 
   strm << "Host: Windows " << major << '.' << minor << " Build: " << update
        << '\n';
 #endif
 }
 
 bool PlatformWindows::CanDebugProcess() { return true; }
 
-size_t PlatformWindows::GetEnvironment(StringList &env) {
+Environment PlatformWindows::GetEnvironment() {
   if (IsRemote()) {
     if (m_remote_platform_sp)
-      return m_remote_platform_sp->GetEnvironment(env);
-    return 0;
+      return m_remote_platform_sp->GetEnvironment();
+    return Environment();
   }
 
-  return Host::GetEnvironment(env);
+  return Host::GetEnvironment();
 }
 
 ConstString PlatformWindows::GetFullNameForDylib(ConstString basename) {
   if (basename.IsEmpty())
     return basename;
 
   StreamString stream;
   stream.Printf("%s.dll", basename.GetCString());
   return ConstString(stream.GetString());
 }

lldb/trunk/source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

m_gdb_client.SetDetachOnError(
       launch_info.GetFlags().Test(eLaunchFlagDetachOnError));
 
   FileSpec working_dir = launch_info.GetWorkingDirectory();
   if (working_dir) {
     m_gdb_client.SetWorkingDir(working_dir);
   }
 
   // Send the environment and the program + arguments after we connect
-  const char **envp =
-      launch_info.GetEnvironmentEntries().GetConstArgumentVector();
-
-  if (envp) {
-    const char *env_entry;
-    for (int i = 0; (env_entry = envp[i]); ++i) {
-      if (m_gdb_client.SendEnvironmentPacket(env_entry) != 0)
-        break;
-    }
-  }
+  m_gdb_client.SendEnvironment(launch_info.GetEnvironment());
 
   ArchSpec arch_spec = launch_info.GetArchitecture();
   const char *arch_triple = arch_spec.GetTriple().str().c_str();
 
   m_gdb_client.SendLaunchArchPacket(arch_triple);
   if (log)
     log->Printf(
         "PlatformRemoteGDBServer::%s() set launch architecture triple to '%s'",

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

#endif
     } while (has_env_var);
 
     if (inferior_args && inferior_args->GetArgumentCount() > 0) {
       debugserver_args.AppendArgument(llvm::StringRef("--"));
       debugserver_args.AppendArguments(*inferior_args);
     }
 
     // Copy the current environment to the gdbserver/debugserver instance
-    StringList env;
-    if (Host::GetEnvironment(env)) {
-      for (size_t i = 0; i < env.GetSize(); ++i)
-        launch_info.GetEnvironmentEntries().AppendArgument(env[i]);
-    }
+    launch_info.GetEnvironment() = Host::GetEnvironment();
 
     // Close STDIN, STDOUT and STDERR.
     launch_info.AppendCloseFileAction(STDIN_FILENO);
     launch_info.AppendCloseFileAction(STDOUT_FILENO);
     launch_info.AppendCloseFileAction(STDERR_FILENO);
 
     // Redirect STDIN, STDOUT and STDERR to "/dev/null".
     launch_info.AppendSuppressFileAction(STDIN_FILENO, true, false);

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

public:
   ///
   /// @return
   ///     Zero if the response was "OK", a positive value if the
   ///     the response was "Exx" where xx are two hex digits, or
   ///     -1 if the call is unsupported or any other unexpected
   ///     response was received.
   //------------------------------------------------------------------
   int SendEnvironmentPacket(char const *name_equal_value);
+  int SendEnvironment(const Environment &env);
 
   int SendLaunchArchPacket(const char *arch);
 
   int SendLaunchEventDataPacket(const char *data,
                                 bool *was_supported = nullptr);
 
   //------------------------------------------------------------------
   /// Sends a "vAttach:PID" where PID is in hex.

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

if (SendPacketAndWaitForResponse(packet.GetString(), response, false) ==
       uint8_t error = response.GetError();
       if (error)
         return error;
     }
   }
   return -1;
 }
 
+int GDBRemoteCommunicationClient::SendEnvironment(const Environment &env) {
+  for (const auto &KV : env) {
+    int r = SendEnvironmentPacket(Environment::compose(KV).c_str());
+    if (r != 0)
+      return r;
+  }
+  return 0;
+}
+
 int GDBRemoteCommunicationClient::SendEnvironmentPacket(
     char const *name_equal_value) {
   if (name_equal_value && name_equal_value[0]) {
     StreamString packet;
     bool send_hex_encoding = false;
     for (const char *p = name_equal_value;
          *p != '\0' && send_hex_encoding == false; ++p) {
       if (isprint(*p)) {

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QEnvironment(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("QEnvironment:"));
   const uint32_t bytes_left = packet.GetBytesLeft();
   if (bytes_left > 0) {
-    m_process_launch_info.GetEnvironmentEntries().AppendArgument(
-        llvm::StringRef::withNullAsEmpty(packet.Peek()));
+    m_process_launch_info.GetEnvironment().insert(packet.Peek());
     return SendOKResponse();
   }
   return SendErrorResponse(12);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QEnvironmentHexEncoded(
     StringExtractorGDBRemote &packet) {
   packet.SetFilePos(::strlen("QEnvironmentHexEncoded:"));
   const uint32_t bytes_left = packet.GetBytesLeft();
   if (bytes_left > 0) {
     std::string str;
     packet.GetHexByteString(str);
-    m_process_launch_info.GetEnvironmentEntries().AppendArgument(str);
+    m_process_launch_info.GetEnvironment().insert(str);
     return SendOKResponse();
   }
   return SendErrorResponse(12);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_QLaunchArch(
     StringExtractorGDBRemote &packet) {

lldb/trunk/source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (error.Success()) {
       if (launch_event_data != NULL && *launch_event_data != '\0')
         m_gdb_comm.SendLaunchEventDataPacket(launch_event_data);
 
       if (working_dir) {
         m_gdb_comm.SetWorkingDir(working_dir);
       }
 
       // Send the environment and the program + arguments after we connect
-      const Args &environment = launch_info.GetEnvironmentEntries();
-      if (environment.GetArgumentCount()) {
-        size_t num_environment_entries = environment.GetArgumentCount();
-        for (size_t i = 0; i < num_environment_entries; ++i) {
-          const char *env_entry = environment.GetArgumentAtIndex(i);
-          if (env_entry == NULL ||
-              m_gdb_comm.SendEnvironmentPacket(env_entry) != 0)
-            break;
-        }
-      }
+      m_gdb_comm.SendEnvironment(launch_info.GetEnvironment());
 
       {
         // Scope for the scoped timeout object
         GDBRemoteCommunication::ScopedTimeout timeout(m_gdb_comm,
                                                       std::chrono::seconds(10));
 
         int arg_packet_err = m_gdb_comm.SendArgumentsPacket(launch_info);
         if (arg_packet_err == 0) {

lldb/trunk/source/Plugins/StructuredData/DarwinLog/StructuredDataDarwinLog.cpp

if (!options_sp && debugger_sp) {
     if (!options_sp || !error.Success())
       return error;
 
     // We already parsed the options, save them now so we don't generate
     // them again until the user runs the command manually.
     SetGlobalEnableOptions(debugger_sp, options_sp);
   }
 
-  auto &env_vars = launch_info.GetEnvironmentEntries();
   if (!options_sp->GetEchoToStdErr()) {
     // The user doesn't want to see os_log/NSLog messages echo to stderr.
     // That mechanism is entirely separate from the DarwinLog support.
     // By default we don't want to get it via stderr, because that would
     // be in duplicate of the explicit log support here.
 
     // Here we need to strip out any OS_ACTIVITY_DT_MODE setting to prevent
     // echoing of os_log()/NSLog() to stderr in the target program.
-    size_t argument_index;
-    if (env_vars.ContainsEnvironmentVariable(
-            llvm::StringRef("OS_ACTIVITY_DT_MODE"), &argument_index))
-      env_vars.DeleteArgumentAtIndex(argument_index);
+    launch_info.GetEnvironment().erase("OS_ACTIVITY_DT_MODE");
 
     // We will also set the env var that tells any downstream launcher
     // from adding OS_ACTIVITY_DT_MODE.
-    env_vars.AddOrReplaceEnvironmentVariable(
-        llvm::StringRef("IDE_DISABLED_OS_ACTIVITY_DT_MODE"),
-        llvm::StringRef("1"));
+    launch_info.GetEnvironment()["IDE_DISABLED_OS_ACTIVITY_DT_MODE"] = "1";
   }
 
   // Set the OS_ACTIVITY_MODE env var appropriately to enable/disable
   // debug and info level messages.
   const char *env_var_value;
   if (options_sp->GetIncludeDebugLevel())
     env_var_value = "debug";
   else if (options_sp->GetIncludeInfoLevel())
     env_var_value = "info";
   else
     env_var_value = "default";
 
-  if (env_var_value) {
-    launch_info.GetEnvironmentEntries().AddOrReplaceEnvironmentVariable(
-        llvm::StringRef("OS_ACTIVITY_MODE"), llvm::StringRef(env_var_value));
-  }
+  launch_info.GetEnvironment()["OS_ACTIVITY_MODE"] = env_var_value;
 
   return error;
 }
 
 bool StructuredDataDarwinLog::InitCompletionHookCallback(
     void *baton, StoppointCallbackContext *context, lldb::user_id_t break_id,
     lldb::user_id_t break_loc_id) {
   // We hit the init function.  We now want to enqueue our new thread plan,

lldb/trunk/source/Target/Platform.cpp

lldb_private::Status OptionGroupPlatformCaching::SetOptionValue(
   default:
     error.SetErrorStringWithFormat("unrecognized option '%c'", short_option);
     break;
   }
 
   return error;
 }
 
-size_t Platform::GetEnvironment(StringList &environment) {
-  environment.Clear();
-  return false;
-}
+Environment Platform::GetEnvironment() { return Environment(); }
 
 const std::vector<ConstString> &Platform::GetTrapHandlerSymbolNames() {
   if (!m_calculated_trap_handlers) {
     std::lock_guard<std::mutex> guard(m_mutex);
     if (!m_calculated_trap_handlers) {
       CalculateTrapHandlerSymbolNames();
       m_calculated_trap_handlers = true;
     }

lldb/trunk/source/Target/Process.cpp

for (uint32_t i = 0; i < argc; i++) {
       const char *arg = m_arguments.GetArgumentAtIndex(i);
       if (i < 10)
         s.Printf(" arg[%u] = %s\n", i, arg);
       else
         s.Printf("arg[%u] = %s\n", i, arg);
     }
   }
 
-  const uint32_t envc = m_environment.GetArgumentCount();
-  if (envc > 0) {
-    for (uint32_t i = 0; i < envc; i++) {
-      const char *env = m_environment.GetArgumentAtIndex(i);
-      if (i < 10)
-        s.Printf(" env[%u] = %s\n", i, env);
-      else
-        s.Printf("env[%u] = %s\n", i, env);
-    }
-  }
+  s.Format("{0}", m_environment);
 
   if (m_arch.IsValid()) {
     s.Printf("   arch = ");
     m_arch.DumpTriple(s);
     s.EOL();
   }
 
   if (m_uid != UINT32_MAX) {
Status ProcessLaunchCommandOptions::SetOptionValue(
   case 'c':
     if (!option_arg.empty())
       launch_info.SetShell(FileSpec(option_arg, false));
     else
       launch_info.SetShell(HostInfo::GetDefaultShell());
     break;
 
   case 'v':
-    launch_info.GetEnvironmentEntries().AppendArgument(option_arg);
+    launch_info.GetEnvironment().insert(option_arg);
     break;
 
   default:
     error.SetErrorStringWithFormat("unrecognized short option character '%c'",
                                    short_option);
     break;
   }
   return error;

lldb/trunk/source/Target/ProcessInfo.cpp

 ProcessInfo::ProcessInfo(const char *name, const ArchSpec &arch,
                          lldb::pid_t pid)
     : m_executable(name, false), m_arguments(), m_environment(),
       m_uid(UINT32_MAX), m_gid(UINT32_MAX), m_arch(arch), m_pid(pid) {}
 
 void ProcessInfo::Clear() {
   m_executable.Clear();
   m_arguments.Clear();
-  m_environment.Clear();
+  m_environment.clear();
   m_uid = UINT32_MAX;
   m_gid = UINT32_MAX;
   m_arch.Clear();
   m_pid = LLDB_INVALID_PROCESS_ID;
 }
 
 const char *ProcessInfo::GetName() const {
   return m_executable.GetFilename().GetCString();
 }
 
 size_t ProcessInfo::GetNameLength() const {
   return m_executable.GetFilename().GetLength();
 }
 
 void ProcessInfo::Dump(Stream &s, Platform *platform) const {
   s << "Executable: " << GetName() << "\n";
   s << "Triple: ";
   m_arch.DumpTriple(s);
   s << "\n";
 
   s << "Arguments:\n";
   m_arguments.Dump(s);
 
-  s << "Environment:\n";
-  m_environment.Dump(s, "env");
+  s.Format("Environment:\n{0}", m_environment);
 }
 
 void ProcessInfo::SetExecutableFile(const FileSpec &exe_file,
                                     bool add_exe_file_as_first_arg) {
   if (exe_file) {
     m_executable = exe_file;
     if (add_exe_file_as_first_arg) {
       llvm::SmallString<PATH_MAX> filename;

lldb/trunk/source/Target/Target.cpp

void GetHostEnvironmentIfNeeded() const {
     if (!m_got_host_env) {
       if (m_target) {
         m_got_host_env = true;
         const uint32_t idx = ePropertyInheritEnv;
         if (GetPropertyAtIndexAsBoolean(
                 nullptr, idx, g_properties[idx].default_uint_value != 0)) {
           PlatformSP platform_sp(m_target->GetPlatform());
           if (platform_sp) {
-            StringList env;
-            if (platform_sp->GetEnvironment(env)) {
-              OptionValueDictionary *env_dict =
-                  GetPropertyAtIndexAsOptionValueDictionary(nullptr,
-                                                            ePropertyEnvVars);
-              if (env_dict) {
-                const bool can_replace = false;
-                const size_t envc = env.GetSize();
-                for (size_t idx = 0; idx < envc; idx++) {
-                  const char *env_entry = env.GetStringAtIndex(idx);
-                  if (env_entry) {
-                    const char *equal_pos = ::strchr(env_entry, '=');
-                    ConstString key;
-                    // It is ok to have environment variables with no values
-                    const char *value = nullptr;
-                    if (equal_pos) {
-                      key.SetCStringWithLength(env_entry,
-                                               equal_pos - env_entry);
-                      if (equal_pos[1])
-                        value = equal_pos + 1;
-                    } else {
-                      key.SetCString(env_entry);
-                    }
-                    // Don't allow existing keys to be replaced with ones we get
-                    // from the platform environment
-                    env_dict->SetValueForKey(
-                        key, OptionValueSP(new OptionValueString(value)),
-                        can_replace);
-                  }
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
+            Environment env = platform_sp->GetEnvironment();
+              for (const auto &KV : env) {
+                    ConstString(KV.first()),
+                    OptionValueSP(new OptionValueString(KV.second.c_str())),
   Target *m_target;
   mutable bool m_got_host_env;
 };
 
 //----------------------------------------------------------------------
 // TargetProperties
 //----------------------------------------------------------------------
 static PropertyDefinition g_experimental_properties[]{

 }
 
 void TargetProperties::SetRunArguments(const Args &args) {
   const uint32_t idx = ePropertyRunArgs;
   m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
   m_launch_info.GetArguments() = args;
 }
 
-size_t TargetProperties::GetEnvironmentAsArgs(Args &env) const {
+Environment TargetProperties::GetEnvironment() const {
+  // TODO: Get rid of the Args intermediate step
+  Args env;
   const uint32_t idx = ePropertyEnvVars;
-  return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, env);
+  m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, env);
+  return Environment(env);
 }
 
-void TargetProperties::SetEnvironmentFromArgs(const Args &env) {
+void TargetProperties::SetEnvironment(Environment env) {
+  // TODO: Get rid of the Args intermediate step
   const uint32_t idx = ePropertyEnvVars;
-  m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, env);
-  m_launch_info.GetEnvironmentEntries() = env;
+  m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, Args(env));
+  m_launch_info.GetEnvironment() = std::move(env);
 }
 
 bool TargetProperties::GetSkipPrologue() const {
   const uint32_t idx = ePropertySkipPrologue;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_properties[idx].default_uint_value != 0);
 }
 
const ProcessLaunchInfo &TargetProperties::GetProcessLaunchInfo() {
   return m_launch_info;
 }
 
 void TargetProperties::SetProcessLaunchInfo(
     const ProcessLaunchInfo &launch_info) {
   m_launch_info = launch_info;
   SetArg0(launch_info.GetArg0());
   SetRunArguments(launch_info.GetArguments());
-  SetEnvironmentFromArgs(launch_info.GetEnvironmentEntries());
+  SetEnvironment(launch_info.GetEnvironment());
   const FileAction *input_file_action =
       launch_info.GetFileActionForFD(STDIN_FILENO);
   if (input_file_action) {
     SetStandardInputPath(input_file_action->GetPath());
   }
   const FileAction *output_file_action =
       launch_info.GetFileActionForFD(STDOUT_FILENO);
   if (output_file_action) {
void TargetProperties::RunArgsValueChangedCallback(void *target_property_ptr,
   if (this_->GetRunArguments(args))
     this_->m_launch_info.GetArguments() = args;
 }
 
 void TargetProperties::EnvVarsValueChangedCallback(void *target_property_ptr,
                                                    OptionValue *) {
   TargetProperties *this_ =
       reinterpret_cast<TargetProperties *>(target_property_ptr);
-  Args args;
-  if (this_->GetEnvironmentAsArgs(args))
-    this_->m_launch_info.GetEnvironmentEntries() = args;
+  this_->m_launch_info.GetEnvironment() = this_->GetEnvironment();
 }
 
 void TargetProperties::InputPathValueChangedCallback(void *target_property_ptr,
                                                      OptionValue *) {
   TargetProperties *this_ =
       reinterpret_cast<TargetProperties *>(target_property_ptr);
   this_->m_launch_info.AppendOpenFileAction(
       STDIN_FILENO, this_->GetStandardInputPath(), true, false);

lldb/trunk/source/Utility/CMakeLists.txt

add_lldb_library(lldbUtility
   ArchSpec.cpp
   Baton.cpp
   Connection.cpp
   ConstString.cpp
   DataBufferHeap.cpp
   DataBufferLLVM.cpp
   DataEncoder.cpp
   DataExtractor.cpp
+  Environment.cpp
   FastDemangle.cpp
   FileSpec.cpp
   History.cpp
   IOObject.cpp
   JSON.cpp
   LLDBAssert.cpp
   Log.cpp
   Logging.cpp

lldb/trunk/source/Utility/Environment.cpp

+//===-- Environment.cpp -----------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Utility/Environment.h"
+
+using namespace lldb_private;
+
+char *Environment::Envp::make_entry(llvm::StringRef Key,
+                                    llvm::StringRef Value) {
+  const size_t size = Key.size() + 1 /*=*/ + Value.size() + 1 /*\0*/;
+  char *Result = reinterpret_cast<char *>(
+      Allocator.Allocate(sizeof(char) * size, alignof(char)));
+  char *Next = Result;
+
+  Next = std::copy(Key.begin(), Key.end(), Next);
+  *Next++ = '=';
+  Next = std::copy(Value.begin(), Value.end(), Next);
+  *Next++ = '\0';
+
+  return Result;
+}
+
+Environment::Envp::Envp(const Environment &Env) {
+  Data = reinterpret_cast<char **>(
+      Allocator.Allocate(sizeof(char *) * (Env.size() + 1), alignof(char *)));
+  char **Next = Data;
+  for (const auto &KV : Env)
+    *Next++ = make_entry(KV.first(), KV.second);
+  *Next++ = nullptr;
+}
+
+Environment::Environment(const char *const *Env) {
+  if (!Env)
+    return;
+  while (*Env)
+    insert(*Env++);
+}
+
+void Environment::insert(const_iterator first, const_iterator last) {
+  while (first != last) {
+    try_emplace(first->first(), first->second);
+    ++first;
+  }
+}

lldb/trunk/tools/lldb-server/lldb-gdbserver.cpp

void handle_launch(GDBRemoteCommunicationServerLLGS &gdb_server, int argc,
   info.SetArguments(const_cast<const char **>(argv), true);
 
   llvm::SmallString<64> cwd;
   if (std::error_code ec = llvm::sys::fs::current_path(cwd)) {
     llvm::errs() << "Error getting current directory: " << ec.message() << "\n";
     exit(1);
   }
   info.SetWorkingDirectory(FileSpec(cwd, true));
-
-  StringList env;
-  Host::GetEnvironment(env);
-  info.GetEnvironmentEntries() = Args(env);
+  info.GetEnvironment() = Host::GetEnvironment();
 
   gdb_server.SetLaunchInfo(info);
 
   Status error = gdb_server.LaunchProcess();
   if (error.Fail()) {
     llvm::errs() << llvm::formatv("error: failed to launch '{0}': {1}\n",
                                   argv[0], error);
     exit(1);

lldb/trunk/unittests/Host/HostTest.cpp

 
 TEST(Host, WaitStatusFormat) {
   EXPECT_EQ("W01", formatv("{0:g}", WaitStatus{WaitStatus::Exit, 1}).str());
   EXPECT_EQ("X02", formatv("{0:g}", WaitStatus{WaitStatus::Signal, 2}).str());
   EXPECT_EQ("S03", formatv("{0:g}", WaitStatus{WaitStatus::Stop, 3}).str());
   EXPECT_EQ("Exited with status 4",
             formatv("{0}", WaitStatus{WaitStatus::Exit, 4}).str());
 }
+
+TEST(Host, GetEnvironment) {
+  putenv(const_cast<char *>("LLDB_TEST_ENVIRONMENT_VAR=Host::GetEnvironment"));
+  ASSERT_EQ("Host::GetEnvironment",
+            Host::GetEnvironment().lookup("LLDB_TEST_ENVIRONMENT_VAR"));
+}

lldb/trunk/unittests/Interpreter/TestArgs.cpp

TEST(ArgsTest, StringToScriptLanguage) {
   EXPECT_TRUE(success);
 
   EXPECT_EQ(lldb::eScriptLanguagePython,
             Args::StringToScriptLanguage(llvm::StringRef("invalid"),
                                          lldb::eScriptLanguagePython,
                                          &success));
   EXPECT_FALSE(success);
 }
-
-TEST(ArgsTest, StringToVersion) {}
-
-// Environment Variable Tests
-
-class EnvVarFixture: public ::testing::Test {
-protected:
-
-    void SetUp() {
-        args.AppendArgument(llvm::StringRef("Arg1=foo"));
-        args.AppendArgument(llvm::StringRef("Arg2"));
-        args.AppendArgument(llvm::StringRef("Arg3=bar"));
-    }
-
-    size_t GetIndexForEnvVar(llvm::StringRef envvar_name) {
-        size_t argument_index = std::numeric_limits<size_t>::max();
-        EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name,
-                                                     &argument_index));
-        EXPECT_LT(argument_index, args.GetArgumentCount());
-        return argument_index;
-    }
-
-    Args  args;
-};
-
-
-TEST_F(EnvVarFixture, TestContainsEnvironmentVariableNoValue) {
-    EXPECT_TRUE(args.ContainsEnvironmentVariable(llvm::StringRef("Arg2")));
-}
-
-TEST_F(EnvVarFixture, TestContainsEnvironmentVariableWithValue) {
-    EXPECT_TRUE(args.ContainsEnvironmentVariable(llvm::StringRef("Arg3")));
-}
-
-TEST_F(EnvVarFixture, TestContainsEnvironmentVariableNonExistentVariable) {
-    auto nonexistent_envvar = llvm::StringRef("ThisEnvVarShouldNotExist");
-    EXPECT_FALSE(args.ContainsEnvironmentVariable(nonexistent_envvar));
-}
-
-TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialNoValueWithNoValue) {
-    auto envvar_name = llvm::StringRef("Arg2");
-    auto argument_index = GetIndexForEnvVar(envvar_name);
-
-    args.AddOrReplaceEnvironmentVariable(envvar_name, llvm::StringRef(""));
-    EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
-    EXPECT_EQ(envvar_name, args.GetArgumentAtIndex(argument_index));
-}
-
-TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialNoValueWithValue) {
-    auto envvar_name = llvm::StringRef("Arg2");
-    auto argument_index = GetIndexForEnvVar(envvar_name);
-
-    auto new_value = llvm::StringRef("NewValue");
-    args.AddOrReplaceEnvironmentVariable(envvar_name, new_value);
-    EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
-
-    std::stringstream stream;
-    stream << envvar_name.str() << '=' << new_value.str();
-    EXPECT_EQ(llvm::StringRef(stream.str()),
-              args.GetArgumentAtIndex(argument_index));
-}
-
-TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialValueWithNoValue) {
-    auto envvar_name = llvm::StringRef("Arg1");
-    auto argument_index = GetIndexForEnvVar(envvar_name);
-
-    args.AddOrReplaceEnvironmentVariable(envvar_name, llvm::StringRef(""));
-    EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
-    EXPECT_EQ(envvar_name, args.GetArgumentAtIndex(argument_index));
-}
-
-TEST_F(EnvVarFixture, TestReplaceEnvironmentVariableInitialValueWithValue) {
-    auto envvar_name = llvm::StringRef("Arg1");
-    auto argument_index = GetIndexForEnvVar(envvar_name);
-
-    auto new_value = llvm::StringRef("NewValue");
-    args.AddOrReplaceEnvironmentVariable(envvar_name, new_value);
-    EXPECT_TRUE(args.ContainsEnvironmentVariable(envvar_name));
-
-    std::stringstream stream;
-    stream << envvar_name.str() << '=' << new_value.str();
-    EXPECT_EQ(llvm::StringRef(stream.str()),
-              args.GetArgumentAtIndex(argument_index));
-}

lldb/trunk/unittests/Utility/CMakeLists.txt

 add_lldb_unittest(UtilityTests
   ArchSpecTest.cpp
   ConstStringTest.cpp
+  EnvironmentTest.cpp
   JSONTest.cpp
   LogTest.cpp
   NameMatchesTest.cpp
   StatusTest.cpp
   StringExtractorTest.cpp
   StructuredDataTest.cpp
   TildeExpressionResolverTest.cpp
   TimeoutTest.cpp

lldb/trunk/unittests/Utility/EnvironmentTest.cpp

+//===-- EnvironmentTest.cpp -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "gtest/gtest.h"
+
+#include "lldb/Utility/Environment.h"
+
+using namespace lldb_private;
+
+TEST(EnvironmentTest, EnvpConstruction) {
+  const char **Envp1 = nullptr;
+  EXPECT_EQ(0u, Environment(Envp1).size());
+
+  const char *Envp2[] = {"FOO=BAR", nullptr};
+  EXPECT_EQ("BAR", Environment(Envp2).lookup("FOO"));
+
+  const char *Envp3[] = {"FOO=BAR", "FOO=BAZ", nullptr};
+  EXPECT_EQ("BAR", Environment(Envp3).lookup("FOO"));
+
+  const char *Envp4[] = {"FOO=", "BAR", nullptr};
+  Environment Env4(Envp4);
+  ASSERT_EQ(2u, Env4.size());
+  EXPECT_EQ("", Environment(Envp4).find("FOO")->second);
+  EXPECT_EQ("", Environment(Envp4).find("BAR")->second);
+
+  const char *Envp5[] = {"FOO=BAR=BAZ", nullptr};
+  EXPECT_EQ("BAR=BAZ", Environment(Envp5).lookup("FOO"));
+}
+
+TEST(EnvironmentTest, EnvpConversion) {
+  std::string FOO_EQ_BAR("FOO=BAR");
+  std::string BAR_EQ_BAZ("BAR=BAZ");
+
+  Environment Env;
+  Env.insert(FOO_EQ_BAR);
+  Env.insert(BAR_EQ_BAZ);
+  Environment::Envp Envp = Env.getEnvp();
+  const char *const *Envp_ = Envp;
+
+  EXPECT_TRUE(FOO_EQ_BAR == Envp_[0] || FOO_EQ_BAR == Envp_[1]);
+  EXPECT_TRUE(BAR_EQ_BAZ == Envp_[0] || BAR_EQ_BAZ == Envp_[1]);
+  EXPECT_EQ(nullptr, Envp_[2]);
+}

lldb/trunk/unittests/tools/lldb-server/tests/TestClient.cpp

if (!InferiorArgs.empty()) {
     args.AppendArgument("--");
     for (StringRef arg : InferiorArgs)
       args.AppendArgument(arg);
   }
 
   ProcessLaunchInfo Info;
   Info.SetArchitecture(arch_spec);
   Info.SetArguments(args, true);
-
-  StringList Env;
-  Host::GetEnvironment(Env);
-  Info.GetEnvironmentEntries() = Args(Env);
+  Info.GetEnvironment() = Host::GetEnvironment();
 
   status = Host::LaunchProcess(Info);
   if (status.Fail())
     return status.ToError();
 
   Socket *accept_socket;
   listen_socket.Accept(accept_socket);
   auto Conn = llvm::make_unique<ConnectionFileDescriptor>(accept_socket);
   auto Client = std::unique_ptr<TestClient>(new TestClient(std::move(Conn)));
 
   if (!InferiorArgs.empty()) {
     if (Error E = Client->QueryProcessInfo())
       return std::move(E);
   }
 
   return std::move(Client);
 }
 
 Error TestClient::SetInferior(llvm::ArrayRef<std::string> inferior_args) {
-  StringList env;
-  Host::GetEnvironment(env);
-  for (size_t i = 0; i < env.GetSize(); ++i) {
-    if (SendEnvironmentPacket(env[i].c_str()) != 0) {
-      return make_error<StringError>(
-          formatv("Failed to set environment variable: {0}", env[i]).str(),
+  if (SendEnvironment(Host::GetEnvironment()) != 0) {
+    return make_error<StringError>("Failed to set launch environment",
                                    inconvertibleErrorCode());
-    }
-  }
   std::stringstream command;
   command << "A";
   for (size_t i = 0; i < inferior_args.size(); i++) {
     if (i > 0)
       command << ',';
     std::string hex_encoded = toHex(inferior_args[i]);
     command << hex_encoded.size() << ',' << i << ',' << hex_encoded;
   }