Create basic SBEnvironment class

[wallace]

Summary

Inspired by https://reviews.llvm.org/D74636, I'm introducing a basic version of Environment in the API. More functionalities can be added as needed.

I tried it in the command line:

(lldb) script
Python Interactive Interpreter. To exit, type 'quit()', 'exit()' or Ctrl-D.
>>> env =lldb.debugger.GetSelectedPlatform().GetEnvironment()
>>> env.Size()
35
>>> env.GetEntryAtIndex(2)
'HOME=/Users/wallace'
>>> env.GetEntryAtIndex(0)
'COMMAND_MODE=unix2003'

[wallace]

format

[jingham]

Thanks for doing this, it will be useful!

I'll let Jonas comment on whether the Reproducer bindings are right, though it looks fine to me.

One of the very common uses of an SBEnvironment is the one in an SBTarget, which gets used to create new processes. With what you have you can get access to it, so that's all good. But you do it by getting the target's platform, and then the Environment from the platform. It might be more discoverable to have the SBTarget hand it out directly as well, however. And there is an lldb_private::Target::GetEnvironment, so it's pretty natural.

Also, you need some tests. You can probably do a lot of it with unit tests. Then maybe a small API test that sets environment variables and fetches them out this way and checks that they are right.

The added API's are up to you. The requested changes are for tests...

[labath]

I'm not sure that this is the right API to represent an environment. The environment is more like a dictionary/map than an array. (The internal Environment object *is* a map, though this does not immediately mean the SB one should be too).

Even for your most immediate use case, you'll want to use the map-like properties of the environment (to "merge" the inherited environment and the user-provided values). With an api like this you'd have to implement all of that by yourself.

So, I am wondering if we shouldn't provide a more map-like interface here too. Rough proposal:

const char *GetEntry(const char *name); // nullptr if not present
void PutEntry(const char *string); // modeled on putenv(3)
void SetEntry(const char *name, const char *value, bool overwrite); //modeled on setenv(3), maybe we can skip it if it's not needed now
SBStringList GetEntries(); // if someone wants to enumerate all of them, maybe also skippable

If we don't want a map-like interface, then maybe we don't actually need a separate class, and an SBStringList would work just fine?

Maybe you could also refactor the other patch to use this new functionality (whatever it ends up being), so that we can see whether it makes sense at least for that use case..

lldb/include/lldb/API/SBEnvironment.h

27–29

s/int/size_t

lldb/source/API/SBEnvironment.cpp

2–3

fix formatting

31–32

new(Environment(rhs))

54

This will return a dangling pointer as Envp is a temporary object. It's intended to be used to pass the environment object to execve-like function.
The current "state of the art" is to ConstStringify all temporary strings that go out of the SB api. (Though I think we should start using std::string).

Also, constructing the Envp object just to fetch a single string out of it is pretty expensive. You can fetch the desired result from the Environment object directly.

Putting it all together, this kind of an API would be implemented via something like:

if (idx >= m_opaque_up->size())
  return nullptr;
return ConstString(Environment::compose(*std::next(m_opaque_up.begin(), idx)).AsCString();

... but I am not sure this is really the right api. More on that in a separate comment.

[jingham]

Yes, a key/value approach would be a better API. Looks like the Environment class would make that pretty easy to wrap up, as well.

[wallace]

Thanks a lot for the feedback! I was thinking about adding features to this class as needed, but definitely I should make this API be more like a map

[clayborg]

lldb/bindings/interface/SBPlatform.i

197–198

What does it mean to get the environment from a platform? Fetching it from the remote platform as what ever binary was used to provide the connection?

lldb/include/lldb/API/SBEnvironment.h

27

return size_t or uint32_t.

Possibly rename to GetNumEntries() to be consistent with all of the other APIs that have a size and item accessor.

29

use size_t or uint32_t (which ever one you pick from Size() above

lldb/include/lldb/API/SBPlatform.h

157

I know there isn't much header documentation here already, but it is a good time to start with any new functions. We would need to detail what this environment would be. Something like: "Return the environment variables contained in the remote platform connection process."

lldb/source/API/SBEnvironment.cpp

47

size_t SBEnvironment::GetNumEnrtries()

54

Yes, any C strings returned from the SB API should use ConstString(cstr).AsCString() as the ConstString puts the string into a string pool and there is no need to clients to destruct the string or take ownership.

No STL in the SB API please, so no std::string. std::string isn't stable on all platforms and competing C++ runtimes on different platforms can cause problems. If we need string ownership, we can introduce SBString as a class.

Please do bounds check this like Pavel requested as the index isn't guaranteed to be valid. If you bounds check first then your code above could be modified to return a ConstString().AsCString().

[wallace]

address comments≈

[wallace]

.

[wallace]

format

[labath]

This looks pretty good overall. I have a bunch of comments, but nothing major.

Could you also please rebase the other patch (D74636) on top of this. I think that a very common use case for this will be taking the platform environment, tweaking it, and then using it to launch a process (i.e. what you are about to do), so it would be good to make sure that flow is sufficiently straight-forward.

lldb/include/lldb/API/SBEnvironment.h

39

This doesn't sounds right.

42–44

Maybe explicitly mention that this overwrites any previous value with that name?

47

we use the name_and_value style elsewhere

lldb/include/lldb/API/SBTarget.h

97

s/or/of

100

s/taget/target/

Also the concept of a "target's environment variables" is somewhat fuzzy. I take it this is the environment that would be used by default to launch a new process (aka the value of target.env-vars setting)?

And maybe also mention that this is a *copy* of that environment (so any changes made to it don't propagate back anywhere)

lldb/source/API/SBEnvironment.cpp

53

Can you check what will this return for non-existing variables and for variables which are set to an empty string FOO=. I have a feeling this will return the same thing, but I would expect to get a nullptr in the first case, and "" in the second.

58

This is using auto just to be fancy. That is not consistent with llvm style.

lldb/test/API/python_api/sbenvironment/TestSBEnvironment.py

32–33

I don't think you actually need to build an inferior for this. target = dbg.CreateTarget("") should be sufficient, I believe.

46

As per the other comment, please also test a case like env.PutEntry("BAZ=")

55

self.assertIn(needle, haystack)

[wallace]

address comments

[wallace]

Thanks for the review!

[clayborg]

We need to determine if the objects we return are copies (from SBPlatform and SBTarget), or if they are objects that will modify the environment for the platform and target respectively. If we are returning copies, we need setters on both the platform and target. If they are references, then they will just update the current environment. I think I would rather have the ability to modify them using the returned object, but I am not set on this if everyone else thinks otherwise.

I added many comments in the SBEnvironment header.

lldb/include/lldb/API/SBEnvironment.h

27

would GetNumValues() be better? Also, if we have this, we need some accessors that work by index:

const char *GetNameAtIndex(size_t);
const char *GetValueAtIndex(size_t);

Again, I would rather people not have to split up the name and value themselves if we can avoid it.

33

Would get Get(...) be better? Mirror the getenv() call?

40

If we can get a list of values and edit the SBStringList, do we want a setter?:

void SetEntries(SBStringList);

47

Change to:

bool Set(const char *name, const char *value, bool overwrite);

The bool indicates if it was set. I would rather people not have to make string values that contain "name=value" just to set an env var. This mirrors the setenv() API in libc

48

We need a Unset accessor:

bool Unset(const char *name);

The returned bool can indicate if the value was removed.

lldb/include/lldb/API/SBTarget.h

97

Maybe better as:

/// Return an object that contains the environment that will be used when 
/// launching processes.

Then we need to explain if this is a copy, or a value that can be modified. It is can be modified, we should add

/// The SBEnvironment object can be used to add or remove environment 
/// variables prior to launching a process.

If it is a copy, mention using the SetEnvironment accessor I mention below

100

If this is a copy of the environment, then there should be a set accessor:

void SBTarget::SetEnvironment(SBEnvironment);

I would be ok with either way (return a copy and have setting, or return the actual object so it can be manipulated). What is the best approach?

lldb/source/API/SBEnvironment.cpp

53

Yes, we need a test for env vars with that are set with no value and it should return "" (non NULL).

[wallace]

Addressed Greg's comments.

At the end I ended up not using APIs that use the format NAME=value, as they could be error prone. I think it's safer to use functions that work with explicit names and values.

Besides, I don't want to complicate this diff, so for now I'd prefer not to add setters for Platform and Target using the Environment class. We can add that later when we need it.

[wallace]

This comment was removed by wallace.

[clayborg]

Just some header doc cleanup before we submit. Thanks for sticking with these changes!

lldb/include/lldb/API/SBEnvironment.h

25

const means nothing in these classes since the ivar will never get modified, so you can remote the leading "const" for the return value.

28

need \param entries in header doc

30

Rephrase the return value docs a bit. Maybe:

/// The value of the environment variable or null if not present. If the environment variable has no value but is present a valid pointer to an empty string will be returned.

Is that what we are doing? Returning "" when variable is there but has no value?

33

need brief description and \param entries in header doc

37

need brief description and \param entries in header doc

38

Need to clarify what happens when the env far is there but has no value. Should match the Get(const char*) function return value with what ever we say is the solution for that.

41

Move above the *AtIndex(size_t) calls so users see this first in API.

45

need \param entries in header doc

51

need \param entries in header doc

[labath]

The new interface is ok for me, but there are two things I want to mention:

• the iteration via Get{Name,Value}AtIndex is going to be slow because the underlying map (like most maps) does not have random access iterators. This is the problem I was trying to solve with the GetEntries-like API, but I agree that has its issues too.
• I agree that forcing a user to manually construct name=value strings if he has then as separate entities is not good, but I also don't think we're doing anyone a favor by not providing an api which would accept such strings. The name=value format is very universal, and I think users will often have the value in this format already (for example, D74636 does). This means that those users would have to implement =-splitting themselves before using this class. This is why the internal Environment class provides both kinds of api, and maybe also the reason why the c library provides both putenv(3) and setenv(3).

lldb/source/API/SBEnvironment.cpp

54

Please reuse the result of m_opaque_up->find(name) here to avoid double lookup.

60

index < 0 is not possible now.

63–74

I don't think these need to const-stringified now, given that they are backed by the underlying map. We already have functions which return pointers to internal objects (e.g. SBStream::GetData).

@clayborg?

81–82

how about if(overwrite) insert_or_assign(name, value) else try_emplace(name, value)? (avoiding two map lookups)

[wallace]

Well, I think I'll implement both kind of accessors in the API to account for all possible cases

[clayborg]

In D76111#1930783, @labath wrote:

The new interface is ok for me, but there are two things I want to mention:

• the iteration via Get{Name,Value}AtIndex is going to be slow because the underlying map (like most maps) does not have random access iterators. This is the problem I was trying to solve with the GetEntries-like API, but I agree that has its issues too.

I am guessing people won't use these much. I didn't know he underlying class used a map. No great solution here unless we modify the underlying class to have a vector with a map of name to index?

• I agree that forcing a user to manually construct name=value strings if he has then as separate entities is not good, but I also don't think we're doing anyone a favor by not providing an api which would accept such strings. The name=value format is very universal, and I think users will often have the value in this format already (for example, D74636 does). This means that those users would have to implement =-splitting themselves before using this class. This is why the internal Environment class provides both kinds of api, and maybe also the reason why the c library provides both putenv(3) and setenv(3).

Fine to add functions for this. The user might grab the environment dump in text and want to set all of those env vars, so having the API is fine with me.

lldb/source/API/SBEnvironment.cpp

60

yeah, size_t is unsigned on all platforms.

63–74

That's a tough one. I would like to think that any "const char *" that comes back from an API that returns strings could just be pointer compared if needed. So I like the idea that for strings that comes out of the API that they are all const-ed and could easily be compared. I am fine with SBStream::GetData() returning its own string because _it_ owns the data. So I would vote to ConstString() any returned results

82

Or do we change the underlying API in the m_opaque_up class to accept an overwrite arg?

lldb/source/API/SBPlatform.cpp

658–660

remove {} (clang code guidelines for single statement if)

lldb/source/API/SBTarget.cpp

2396–2398

remove {} (clang code guidelines for single statement if)

[wallace]

lldb/source/API/SBEnvironment.cpp

63–74

I'm adding a Clear method. With that, the backing char* might be wiped out and the python reference to this string might be invalid unless we use ConstString

81–82

teach me more

[wallace]

• Added both kinds of APIs we were discussing. It will come handy for all different kind of usages
• Added an SBEnvironment API for SBLaunchInfo, which will be used in https://reviews.llvm.org/D74636
• Address all sorts of comments

[wallace]

fix grammar

[labath]

This looks good to me. I still have some doubts about the ConstStringification of the returned values (I am not a fan of constifying everything), but I don't want to block this review for that.

lldb/source/API/SBEnvironment.cpp

27

move this into the initializer list?

30

super-nit: if you make this constructor accept a Environment rhs (without the const & part) and then do the initialization as new Environment(std::move(rhs)), you will avoid copying the environment in the expressions like SBEnvironment(Environment(whatever)). Currently that will create one Environment object to initialize the rhs argument, and then a second one when copying things to m_opaque_up.

63–74

I am fine with SBStream::GetData() returning its own string because _it_ owns the data.

I am afraid I don't see the distinction here. SBStream owns a Stream (via a unique_ptr) and the stream data is inside that. An SBEnvironment has a unique_ptr<Environment>, and the strings are inside of that.

I'm adding a Clear method. With that, the backing char* might be wiped out and the python reference to this string might be invalid unless we use ConstString

Python will be fine if as it will copy the string as soon as it gets its hand on it. C++ users could be affected by that, but, this is not something that should come across as surprising to them (and indeed, the same thing will happen with SBStream::GetData).

[wallace]

apply last suggestions

[wallace]

Thanks a lot, guys. I learned a lot from you doing this patch :)

[aprantl]

It looks like this test doesn't work on the bots: http://green.lab.llvm.org/green//view/LLDB/job/lldb-cmake/lastCompletedBuild//testReport/junit/lldb-api/python_api_sbenvironment/TestSBEnvironment_py/

[aprantl]

Since it's late on Friday afternoon I'm taking the liberty to revert the patch to get the bots running again. Feel free to re-land with a fix or ask for another round of review if you have more questions.

[MaskRay]

commit fd868f517d2c5ca8c0f160dbec0857b14ecf74c1 should be associated with Differential Revision: https://reviews.llvm.org/D76111.

The revert of fd868f517d2c5ca8c0f160dbec0857b14ecf74c1 should explain why fd868f517d2c5ca8c0f160dbec0857b14ecf74c1 was reverted.

Please don't make a commit whose description contains just one word fix.

If you are unsure, upload a new diff to trigger Harbormaster, check its test status on 3 Linux/Windows/macOS, instead of committing and reverting like playing a game. Every commit has a permanent record which will be shared among thousands of developers and can increase the size of the repository. Please be careful.

Subscribers: and Tags: lines are generally considered useless. You can strip them with:

arcfilter () {
        git log -1 --pretty=%B | awk '/Reviewers:|Subscribers:/{p=1} /Reviewed By:|Differential Revision:/{p=0} !p && !/^Summary:$/ {sub(/^Summary: /,"");print}' | git commit --amend -F -
}

[wallace]

Thanks for the notice. I apologize for not doing everything correctly. I'm still trying to understand how all the different piece of the system works and I end up learning from the things that fail...

lldb/bindings/headers.swig

 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBCommunication.h"
 #include "lldb/API/SBCompileUnit.h"
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDeclaration.h"
+#include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExecutionContext.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFile.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBFrame.h"

lldb/bindings/interface/SBEnvironment.i

+//===-- SWIG Interface for SBEnvironment-------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+namespace lldb {
+
+%feature("docstring",
+"Represents the environment of a certain process.
+
+Example:
+  for entry in lldb.debugger.GetSelectedTarget().GetEnvironment().GetEntries():
+    print(entry)
+
+") SBEnvironment;
+class SBEnvironment {
+public:
+    SBEnvironment ();
+
+    SBEnvironment (const lldb::SBEnvironment &rhs);
+
+    ~SBEnvironment();
+
+    size_t GetNumValues();
+
+    const char *Get(const char *name);
+
+    const char *GetNameAtIndex(size_t index);
+
+    const char *GetValueAtIndex(size_t index);
+
+    SBStringList GetEntries();
+
+    void PutEntry(const char *name_and_value);
+
+    void SetEntries(const SBStringList &entries, bool append);
+
+    bool Set(const char *name, const char *value, bool overwrite);
+
+    bool Unset(const char *name);
+
+    void Clear();
+};
+
+} // namespace lldb

lldb/bindings/interface/SBLaunchInfo.i

public:
 
     const char *
     GetEnvironmentEntryAtIndex (uint32_t idx);
 
     void
     SetEnvironmentEntries (const char **envp, bool append);
 
     void
+    SetEnvironment(const SBEnvironment &env, bool append);
+
+    SBEnvironment
+    GetEnvironment();
+
+    void
     Clear ();
 
     const char *
     GetWorkingDirectory () const;
 
     void
     SetWorkingDirectory (const char *working_dir);
 

lldb/bindings/interface/SBPlatform.i

public:
     GetFilePermissions (const char *path);
 
     lldb::SBError
     SetFilePermissions (const char *path, uint32_t file_permissions);
 
     lldb::SBUnixSignals
     GetUnixSignals();
 
+    lldb::SBEnvironment
+    GetEnvironment();
+
 };
 
 } // namespace lldb

lldb/bindings/interface/SBTarget.i

#endif
     lldb::SBBreakpoint
     BreakpointCreateForException  (lldb::LanguageType language,
                                    bool catch_bp,
                                    bool throw_bp);
 
     lldb::SBBreakpoint
     BreakpointCreateByAddress (addr_t address);
 
+    lldb::SBEnvironment
+    GetEnvironment();
+
     lldb::SBBreakpoint
     BreakpointCreateBySBAddress (SBAddress &sb_address);
 
     %feature("docstring", "
     Create a breakpoint using a scripted resolver.
 
     @param[in] class_name
        This is the name of the class that implements a scripted resolver.

lldb/bindings/interfaces.swig

 %include "./interface/SBCommandInterpreter.i"
 %include "./interface/SBCommandReturnObject.i"
 %include "./interface/SBCommunication.i"
 %include "./interface/SBCompileUnit.i"
 %include "./interface/SBData.i"
 %include "./interface/SBDebugger.i"
 %include "./interface/SBDeclaration.i"
 %include "./interface/SBError.i"
+%include "./interface/SBEnvironment.i"
 %include "./interface/SBEvent.i"
 %include "./interface/SBExecutionContext.i"
 %include "./interface/SBExpressionOptions.i"
 %include "./interface/SBFile.i"
 %include "./interface/SBFileSpec.i"
 %include "./interface/SBFileSpecList.i"
 %include "./interface/SBFrame.i"
 %include "./interface/SBFunction.i"

lldb/include/lldb/API/LLDB.h

 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBCommandReturnObject.h"
 #include "lldb/API/SBCommunication.h"
 #include "lldb/API/SBCompileUnit.h"
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBDefines.h"
+#include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExecutionContext.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFile.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBFrame.h"

lldb/include/lldb/API/SBDefines.h

 class LLDB_API SBCommandInterpreterRunOptions;
 class LLDB_API SBCommandPluginInterface;
 class LLDB_API SBCommandReturnObject;
 class LLDB_API SBCommunication;
 class LLDB_API SBCompileUnit;
 class LLDB_API SBData;
 class LLDB_API SBDebugger;
 class LLDB_API SBDeclaration;
+class LLDB_API SBEnvironment;
 class LLDB_API SBError;
 class LLDB_API SBEvent;
 class LLDB_API SBEventList;
 class LLDB_API SBExecutionContext;
 class LLDB_API SBExpressionOptions;
 class LLDB_API SBFile;
 class LLDB_API SBFileSpec;
 class LLDB_API SBFileSpecList;

lldb/include/lldb/API/SBEnvironment.h

+//===-- SBEnvironment.h -----------------------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_API_SBENVIRONMENT_H
+#define LLDB_API_SBENVIRONMENT_H
+
+#include "lldb/API/SBDefines.h"
+
+namespace lldb {
+
+class LLDB_API SBEnvironment {
+public:
+  SBEnvironment();
+
+  SBEnvironment(const lldb::SBEnvironment &rhs);
+
+  ~SBEnvironment();
+
+  lldb::SBEnvironment &operator=(const lldb::SBEnvironment &rhs);
+
+  /// Return the value of a given environment variable.
+  ///
+  /// \param [in] name
+  ///     The name of the environment variable.
+  ///
+  /// \return
+  ///     The value of the enviroment variable or null if not present.
+  ///     If the environment variable has no value but is present, a valid
+  ///     pointer to an empty string will be returned.
+  const char *Get(const char *name);
+
+  /// \return
+  ///     The number of environment variables.
+  size_t GetNumValues();
+
+  /// Return the name of the environment variable at a given index from the
+  /// internal list of environment variables.
+  ///
+  /// \param [in] index
+  ///     The index of the environment variable in the internal list.
+  ///
+  /// \return
+  ///     The name at the given index or null if the index is invalid.
+  const char *GetNameAtIndex(size_t index);
+
+  /// Return the value of the environment variable at a given index from the
+  /// internal list of environment variables.
+  ///
+  /// \param [in] index
+  ///     The index of the environment variable in the internal list.
+  ///
+  /// \return
+  ///     The value at the given index or null if the index is invalid.
+  ///     If the environment variable has no value but is present, a valid
+  ///     pointer to an empty string will be returned.
+  const char *GetValueAtIndex(size_t index);
+
+  /// Return all environment variables contained in this object. Each variable
+  /// is returned as a string with the following format
+  ///     name=value
+  ///
+  /// \return
+  ///     Return an lldb::SBStringList object with the environment variables.
+  SBStringList GetEntries();
+
+  /// Add or replace an existing environment variable. The input must be a
+  /// string with the format
+  ///     name=value
+  ///
+  /// \param [in] name_and_value
+  ///     The entry to set which conforms to the format mentioned above.
+  void PutEntry(const char *name_and_value);
+
+  /// Update this object with the given environment variables. The input is a
+  /// list of entries with the same format required by SBEnvironment::PutEntry.
+  ///
+  /// If append is false, the provided environment will replace the existing
+  /// environment. Otherwise, existing values will be updated of left untouched
+  /// accordingly.
+  ///
+  /// \param [in] entries
+  ///     The environment variable entries.
+  ///
+  /// \param [in] append
+  ///     Flag that controls whether to replace the existing environment.
+  void SetEntries(const SBStringList &entries, bool append);
+
+  /// Set the value of a given environment variable.
+  /// If the variable exists, its value is updated only if overwrite is true.
+  ///
+  /// \param [in] name
+  ///     The name of the environment variable to set.
+  ///
+  /// \param [in] value
+  ///     The value of the environment variable to set.
+  ///
+  /// \param [in] overwrite
+  ///     Flag that indicates whether to overwrite an existing environment
+  ///     variable.
+  ///
+  /// \return
+  ///     Return whether the variable was added or modified.
+  bool Set(const char *name, const char *value, bool overwrite);
+
+  /// Unset an environment variable if exists.
+  ///
+  /// \param [in] name
+  ///     The name of the environment variable to unset.
+  ///
+  /// \return
+  ///     Return whether a variable was actually unset.
+  bool Unset(const char *name);
+
+  /// Delete all the environment variables.
+  void Clear();
+
+protected:
+  friend class SBPlatform;
+  friend class SBTarget;
+  friend class SBLaunchInfo;
+
+  SBEnvironment(lldb_private::Environment rhs);
+
+  lldb_private::Environment &ref() const;
+
+private:
+  std::unique_ptr<lldb_private::Environment> m_opaque_up;
+};
+
+} // namespace lldb
+
+#endif // LLDB_API_SBENVIRONMENT_H

lldb/include/lldb/API/SBLaunchInfo.h

public:
   const char *GetArgumentAtIndex(uint32_t idx);
 
   void SetArguments(const char **argv, bool append);
 
   uint32_t GetNumEnvironmentEntries();
 
   const char *GetEnvironmentEntryAtIndex(uint32_t idx);
 
+  /// Update this object with the given environment variables.
+  ///
+  /// If append is false, the provided environment will replace the existing
+  /// environment. Otherwise, existing values will be updated of left untouched
+  /// accordingly.
+  ///
+  /// \param [in] envp
+  ///     The new environment variables as a list of strings with the following
+  ///     format
+  ///         name=value
+  ///
+  /// \param [in] append
+  ///     Flag that controls whether to replace the existing environment.
   void SetEnvironmentEntries(const char **envp, bool append);
 
+  /// Update this object with the given environment variables.
+  ///
+  /// If append is false, the provided environment will replace the existing
+  /// environment. Otherwise, existing values will be updated of left untouched
+  /// accordingly.
+  ///
+  /// \param [in] env
+  ///     The new environment variables.
+  ///
+  /// \param [in] append
+  ///     Flag that controls whether to replace the existing environment.
+  void SetEnvironment(const SBEnvironment &env, bool append);
+
+  /// Return the environment variables of this object.
+  ///
+  /// \return
+  ///     An lldb::SBEnvironment object which is a copy of the SBLaunchInfo's
+  ///     environment.
+  SBEnvironment GetEnvironment();
+
   void Clear();
 
   const char *GetWorkingDirectory() const;
 
   void SetWorkingDirectory(const char *working_dir);
 
   uint32_t GetLaunchFlags();
 

lldb/include/lldb/API/SBPlatform.h

MakeDirectory(const char *path,
                 uint32_t file_permissions = eFilePermissionsDirectoryDefault);
 
   uint32_t GetFilePermissions(const char *path);
 
   SBError SetFilePermissions(const char *path, uint32_t file_permissions);
 
   SBUnixSignals GetUnixSignals() const;
 
+  /// Return the environment variables of the remote platform connection
+  /// process.
+  ///
+  /// \return
+  ///     An lldb::SBEnvironment object which is a copy of the platform's
+  ///     enviroment.
+  SBEnvironment GetEnvironment();
+
 protected:
   friend class SBDebugger;
   friend class SBTarget;
 
   lldb::PlatformSP GetSP() const;
 
   void SetSP(const lldb::PlatformSP &platform_sp);
 

lldb/include/lldb/API/SBTarget.h

public:
   ///
   /// After return, the platform object should be checked for
   /// validity.
   ///
   /// \return
   ///     A platform object.
   lldb::SBPlatform GetPlatform();
 
+  /// Return the environment variables that would be used to launch a new
+  /// process.
+  ///
+  /// \return
+  ///     An lldb::SBEnvironment object which is a copy of the target's
+  ///     environment.
+
+  SBEnvironment GetEnvironment();
+
   /// Install any binaries that need to be installed.
   ///
   /// This function does nothing when debugging on the host system.
   /// When connected to remote platforms, the target's main executable
   /// and any modules that have their remote install path set will be
   /// installed on the remote platform. If the main executable doesn't
   /// have an install location set, it will be installed in the remote
   /// platform's working directory.

lldb/include/lldb/Utility/Environment.h

public:
   using Base::begin;
   using Base::clear;
   using Base::count;
   using Base::empty;
   using Base::end;
   using Base::erase;
   using Base::find;
   using Base::insert;
+  using Base::insert_or_assign;
   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)) {}

lldb/include/lldb/lldb-forward.h

 class Declaration;
 class DiagnosticManager;
 class Disassembler;
 class DumpValueObjectOptions;
 class DynamicCheckerFunctions;
 class DynamicLoader;
 class Editline;
 class EmulateInstruction;
+class Environment;
 class EvaluateExpressionOptions;
 class Event;
 class EventData;
 class EventDataStructuredData;
 class ExecutionContext;
 class ExecutionContextRef;
 class ExecutionContextScope;
 class Expression;

lldb/source/API/CMakeLists.txt

add_lldb_library(liblldb SHARED ${option_framework}
   SBBroadcaster.cpp
   SBCommandInterpreter.cpp
   SBCommandReturnObject.cpp
   SBCommunication.cpp
   SBCompileUnit.cpp
   SBData.cpp
   SBDebugger.cpp
   SBDeclaration.cpp
+  SBEnvironment.cpp
   SBError.cpp
   SBEvent.cpp
   SBExecutionContext.cpp
   SBExpressionOptions.cpp
   SBFileSpec.cpp
   SBFile.cpp
   SBFileSpecList.cpp
   SBFrame.cpp

lldb/source/API/SBEnvironment.cpp

+//===-- SBEnvironment.cpp -------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/API/SBEnvironment.h"
+#include "SBReproducerPrivate.h"
+#include "Utils.h"
+#include "lldb/API/SBStringList.h"
+#include "lldb/Utility/Environment.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+SBEnvironment::SBEnvironment() : m_opaque_up(new Environment()) {
+  LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEnvironment);
+}
+
+SBEnvironment::SBEnvironment(const SBEnvironment &rhs)
+    : m_opaque_up(clone(rhs.m_opaque_up)) {
+  LLDB_RECORD_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &), rhs);
+}
+
+SBEnvironment::SBEnvironment(Environment rhs)
+    : m_opaque_up(new Environment(std::move(rhs))) {}
+
+SBEnvironment::~SBEnvironment() = default;
+
+SBEnvironment &SBEnvironment::operator=(const SBEnvironment &rhs) {
+  LLDB_RECORD_METHOD(lldb::SBEnvironment &,
+                     SBEnvironment, operator=,(const lldb::SBEnvironment &),
+                     rhs);
+
+  if (this != &rhs)
+    m_opaque_up = clone(rhs.m_opaque_up);
+  return LLDB_RECORD_RESULT(*this);
+}
+
+size_t SBEnvironment::GetNumValues() {
+  LLDB_RECORD_METHOD_NO_ARGS(size_t, SBEnvironment, GetNumValues);
+  return LLDB_RECORD_RESULT(m_opaque_up->size());
+}
+
+const char *SBEnvironment::Get(const char *name) {
+  LLDB_RECORD_METHOD(const char *, SBEnvironment, Get, (const char *), name);
+  auto entry = m_opaque_up->find(name);
+  if (entry == m_opaque_up->end())
+    return LLDB_RECORD_RESULT(nullptr);
+  return LLDB_RECORD_RESULT(ConstString(entry->second).AsCString(""));
+}
+
+const char *SBEnvironment::GetNameAtIndex(size_t index) {
+  LLDB_RECORD_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t),
+                     index);
+  if (index >= GetNumValues())
+    return LLDB_RECORD_RESULT(nullptr);
+  return LLDB_RECORD_RESULT(
+      ConstString(std::next(m_opaque_up->begin(), index)->first())
+          .AsCString(""));
+}
+
+const char *SBEnvironment::GetValueAtIndex(size_t index) {
+  LLDB_RECORD_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t),
+                     index);
+  if (index < 0 || index >= GetNumValues())
+    return LLDB_RECORD_RESULT(nullptr);
+  return LLDB_RECORD_RESULT(
+      ConstString(std::next(m_opaque_up->begin(), index)->second)
+          .AsCString(""));
+}
+
+bool SBEnvironment::Set(const char *name, const char *value, bool overwrite) {
+  LLDB_RECORD_METHOD(bool, SBEnvironment, Set,
+                     (const char *, const char *, bool), name, value,
+                     overwrite);
+  if (overwrite) {
+    m_opaque_up->insert_or_assign(name, std::string(value));
+    return LLDB_RECORD_RESULT(true);
+  }
+  return LLDB_RECORD_RESULT(
+      m_opaque_up->try_emplace(name, std::string(value)).second);
+}
+
+bool SBEnvironment::Unset(const char *name) {
+  LLDB_RECORD_METHOD(bool, SBEnvironment, Unset, (const char *), name);
+  return LLDB_RECORD_RESULT(m_opaque_up->erase(name));
+}
+
+SBStringList SBEnvironment::GetEntries() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBStringList, SBEnvironment, GetEntries);
+  SBStringList entries;
+  for (const auto &KV : *m_opaque_up) {
+    entries.AppendString(Environment::compose(KV).c_str());
+  }
+  return LLDB_RECORD_RESULT(entries);
+}
+
+void SBEnvironment::PutEntry(const char *name_and_value) {
+  LLDB_RECORD_METHOD(void, SBEnvironment, PutEntry, (const char *),
+                     name_and_value);
+  auto split = llvm::StringRef(name_and_value).split('=');
+  m_opaque_up->insert_or_assign(split.first.str(), split.second.str());
+}
+
+void SBEnvironment::SetEntries(const SBStringList &entries, bool append) {
+  LLDB_RECORD_METHOD(void, SBEnvironment, SetEntries,
+                     (const SBStringList &, bool), entries, append);
+  if (!append)
+    m_opaque_up->clear();
+  for (size_t i = 0; i < entries.GetSize(); i++) {
+    PutEntry(entries.GetStringAtIndex(i));
+  }
+}
+
+void SBEnvironment::Clear() {
+  LLDB_RECORD_METHOD_NO_ARGS(void, SBEnvironment, Clear);
+  m_opaque_up->clear();
+}
+
+Environment &SBEnvironment::ref() const { return *m_opaque_up; }
+
+namespace lldb_private {
+namespace repro {
+
+template <> void RegisterMethods<SBEnvironment>(Registry &R) {
+  LLDB_REGISTER_CONSTRUCTOR(SBEnvironment, ());
+  LLDB_REGISTER_CONSTRUCTOR(SBEnvironment, (const lldb::SBEnvironment &));
+  LLDB_REGISTER_METHOD(lldb::SBEnvironment &,
+                       SBEnvironment, operator=,(const lldb::SBEnvironment &));
+  LLDB_REGISTER_METHOD(size_t, SBEnvironment, GetNumValues, ());
+  LLDB_REGISTER_METHOD(const char *, SBEnvironment, GetNameAtIndex, (size_t));
+  LLDB_REGISTER_METHOD(const char *, SBEnvironment, GetValueAtIndex, (size_t));
+  LLDB_REGISTER_METHOD(const char *, SBEnvironment, Get, (const char *));
+  LLDB_REGISTER_METHOD(bool, SBEnvironment, Set,
+                       (const char *, const char *, bool));
+  LLDB_REGISTER_METHOD(bool, SBEnvironment, Unset, (const char *));
+  LLDB_REGISTER_METHOD(lldb::SBStringList, SBEnvironment, GetEntries, ());
+  LLDB_REGISTER_METHOD(void, SBEnvironment, PutEntry, (const char *));
+  LLDB_REGISTER_METHOD(void, SBEnvironment, SetEntries,
+                       (const SBStringList &, bool));
+}
+
+} // namespace repro
+} // namespace lldb_private

lldb/source/API/SBLaunchInfo.cpp

 //===-- SBLaunchInfo.cpp --------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBLaunchInfo.h"
 #include "SBReproducerPrivate.h"
 
+#include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/Host/ProcessLaunchInfo.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 class lldb_private::SBLaunchInfoImpl : public ProcessLaunchInfo {
const char *SBLaunchInfo::GetEnvironmentEntryAtIndex(uint32_t idx) {
   if (idx > GetNumEnvironmentEntries())
     return nullptr;
   return m_opaque_sp->GetEnvp()[idx];
 }
 
 void SBLaunchInfo::SetEnvironmentEntries(const char **envp, bool append) {
   LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironmentEntries,
                      (const char **, bool), envp, append);
+  SetEnvironment(SBEnvironment(Environment(envp)), append);
+}
 
-  Environment env(envp);
+void SBLaunchInfo::SetEnvironment(const SBEnvironment &env, bool append) {
+  LLDB_RECORD_METHOD(void, SBLaunchInfo, SetEnvironment,
+                     (const lldb::SBEnvironment &, bool), env, append);
+  Environment &refEnv = env.ref();
   if (append)
-    m_opaque_sp->GetEnvironment().insert(env.begin(), env.end());
+    m_opaque_sp->GetEnvironment().insert(refEnv.begin(), refEnv.end());
   else
-    m_opaque_sp->GetEnvironment() = env;
+    m_opaque_sp->GetEnvironment() = refEnv;
   m_opaque_sp->RegenerateEnvp();
 }
 
+SBEnvironment SBLaunchInfo::GetEnvironment() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment);
+  return LLDB_RECORD_RESULT(
+      SBEnvironment(Environment(m_opaque_sp->GetEnvironment())));
+}
+
 void SBLaunchInfo::Clear() {
   LLDB_RECORD_METHOD_NO_ARGS(void, SBLaunchInfo, Clear);
 
   m_opaque_sp->Clear();
 }
 
 const char *SBLaunchInfo::GetWorkingDirectory() const {
   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBLaunchInfo,
void RegisterMethods<SBLaunchInfo>(Registry &R) {
   LLDB_REGISTER_METHOD(bool, SBLaunchInfo, AddSuppressFileAction,
                        (int, bool, bool));
   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetLaunchEventData,
                        (const char *));
   LLDB_REGISTER_METHOD_CONST(const char *, SBLaunchInfo, GetLaunchEventData,
                              ());
   LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetDetachOnError, (bool));
   LLDB_REGISTER_METHOD_CONST(bool, SBLaunchInfo, GetDetachOnError, ());
+  LLDB_REGISTER_METHOD(void, SBLaunchInfo, SetEnvironment,
+                       (const lldb::SBEnvironment &, bool));
+  LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBLaunchInfo, GetEnvironment, ());
 }
 
 }
 }

lldb/source/API/SBPlatform.cpp

 //===-- SBPlatform.cpp ----------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBPlatform.h"
 #include "SBReproducerPrivate.h"
+#include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBLaunchInfo.h"
+#include "lldb/API/SBPlatform.h"
 #include "lldb/API/SBUnixSignals.h"
 #include "lldb/Host/File.h"
 #include "lldb/Target/Platform.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/Status.h"
 
LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBUnixSignals, SBPlatform,
                                    GetUnixSignals);
 
   if (auto platform_sp = GetSP())
     return LLDB_RECORD_RESULT(SBUnixSignals{platform_sp});
 
   return LLDB_RECORD_RESULT(SBUnixSignals());
 }
 
+SBEnvironment SBPlatform::GetEnvironment() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBPlatform, GetEnvironment);
+  PlatformSP platform_sp(GetSP());
+
+  if (platform_sp) {
+    return LLDB_RECORD_RESULT(SBEnvironment(platform_sp->GetEnvironment()));
+  }
+
+  return LLDB_RECORD_RESULT(SBEnvironment());
+}
+
 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBPlatformConnectOptions>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions, (const char *));
   LLDB_REGISTER_CONSTRUCTOR(SBPlatformConnectOptions,
                             (const lldb::SBPlatformConnectOptions &));
LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Launch,
                        (lldb::SBLaunchInfo &));
   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, Kill, (const lldb::pid_t));
   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, MakeDirectory,
                        (const char *, uint32_t));
   LLDB_REGISTER_METHOD(uint32_t, SBPlatform, GetFilePermissions,
                        (const char *));
   LLDB_REGISTER_METHOD(lldb::SBError, SBPlatform, SetFilePermissions,
                        (const char *, uint32_t));
+  LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBPlatform, GetEnvironment, ());
   LLDB_REGISTER_METHOD_CONST(lldb::SBUnixSignals, SBPlatform, GetUnixSignals,
                              ());
 }
 
 }
 }

lldb/source/API/SBTarget.cpp

 //===-- SBTarget.cpp ------------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBTarget.h"
 #include "SBReproducerPrivate.h"
 
 #include "lldb/lldb-public.h"
 
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBDebugger.h"
+#include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBExpressionOptions.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBModule.h"
 #include "lldb/API/SBModuleSpec.h"
 #include "lldb/API/SBProcess.h"
 #include "lldb/API/SBSourceManager.h"
void SBTarget::SetLaunchInfo(const lldb::SBLaunchInfo &launch_info) {
   LLDB_RECORD_METHOD(void, SBTarget, SetLaunchInfo,
                      (const lldb::SBLaunchInfo &), launch_info);
 
   TargetSP target_sp(GetSP());
   if (target_sp)
     m_opaque_sp->SetProcessLaunchInfo(launch_info.ref());
 }
 
+SBEnvironment SBTarget::GetEnvironment() {
+  LLDB_RECORD_METHOD_NO_ARGS(lldb::SBEnvironment, SBTarget, GetEnvironment);
+  TargetSP target_sp(GetSP());
+
+  if (target_sp) {
+    return LLDB_RECORD_RESULT(SBEnvironment(target_sp->GetEnvironment()));
+  }
+
+  return LLDB_RECORD_RESULT(SBEnvironment());
+}
+
 namespace lldb_private {
 namespace repro {
 
 template <>
 void RegisterMethods<SBTarget>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBTarget, ());
   LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::SBTarget &));
   LLDB_REGISTER_CONSTRUCTOR(SBTarget, (const lldb::TargetSP &));
void RegisterMethods<SBTarget>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget,
                        GetInstructionsWithFlavor,
                        (lldb::SBAddress, const char *, const void *, size_t));
   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget, GetInstructions,
                        (lldb::addr_t, const void *, size_t));
   LLDB_REGISTER_METHOD(lldb::SBInstructionList, SBTarget,
                        GetInstructionsWithFlavor,
                        (lldb::addr_t, const char *, const void *, size_t));
+  LLDB_REGISTER_METHOD(lldb::SBEnvironment, SBTarget, GetEnvironment, ());
 }
 
 }
 }

lldb/test/API/python_api/sbenvironment/TestSBEnvironment.py

+"""Test the SBEnvironment APIs."""
+
+
+
+from math import fabs
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+class SBEnvironmentAPICase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
+
+    # We use this function to test both kind of accessors:
+    # .  Get*AtIndex and GetEntries
+    def assertEqualEntries(self, env, entries):
+        self.assertEqual(env.GetNumValues(), len(entries))
+        for i in range(env.GetNumValues()):
+            name = env.GetNameAtIndex(i)
+            value = env.GetValueAtIndex(i)
+            self.assertIn(name + "=" + value, entries)
+
+        entries = env.GetEntries()
+        self.assertEqual(entries.GetSize(), len(entries))
+        for i in range(entries.GetSize()):
+            (name, value) = entries.GetStringAtIndex(i).split("=")
+            self.assertIn(name + "=" + value, entries)
+
+
+
+    @add_test_categories(['pyapi'])
+    def test_platform_environment(self):
+        env = self.dbg.GetSelectedPlatform().GetEnvironment()
+        # We assume at least PATH is set
+        self.assertNotEqual(env.Get("PATH"), None)
+
+
+    @add_test_categories(['pyapi'])
+    def test_launch_info(self):
+        target = self.dbg.CreateTarget("")
+        launch_info = target.GetLaunchInfo()
+        env = launch_info.GetEnvironment()
+        self.assertEqual(env.GetNumValues(), 0)
+
+        env.Set("FOO", "bar", overwrite=True)
+        self.assertEqual(env.GetNumValues(), 1)
+
+        # Make sure we only modify the copy of the launchInfo's environment
+        self.assertEqual(launch_info.GetEnvironment().GetNumValues(), 0)
+
+        launch_info.SetEnvironment(env, append=True)
+        self.assertEqual(launch_info.GetEnvironment().GetNumValues(), 1)
+
+        # Make sure we can replace the launchInfo's environment
+        env.Clear()
+        env.Set("BAR", "foo", overwrite=True)
+        env.PutEntry("X=y")
+        launch_info.SetEnvironment(env, append=False)
+        self.assertEqualEntries(launch_info.GetEnvironment(), ["BAR=foo", "X=y"])
+
+
+    @add_test_categories(['pyapi'])
+    def test_target_environment(self):
+        env = self.dbg.GetSelectedTarget().GetEnvironment()
+        # There is no target, so env should be empty
+        self.assertEqual(env.GetNumValues(), 0)
+        self.assertEqual(env.Get("PATH"), None)
+
+        target = self.dbg.CreateTarget("")
+        env = target.GetEnvironment()
+        path = env.Get("PATH")
+        # Now there's a target, so at least PATH should exist
+        self.assertNotEqual(path, None)
+
+        # Make sure we are getting a copy by modifying the env we just got
+        env.PutEntry("PATH=#" + path)
+        self.assertEqual(target.GetEnvironment().Get("PATH"), path)
+
+    @add_test_categories(['pyapi'])
+    def test_creating_and_modifying_environment(self):
+        env = lldb.SBEnvironment()
+
+        self.assertEqual(env.Get("FOO"), None)
+        self.assertEqual(env.Get("BAR"), None)
+
+        # We also test empty values
+        self.assertTrue(env.Set("FOO", "", overwrite=False))
+        env.Set("BAR", "foo", overwrite=False)
+
+        self.assertEqual(env.Get("FOO"), "")
+        self.assertEqual(env.Get("BAR"), "foo")
+
+        self.assertEqual(env.GetNumValues(), 2)
+
+        self.assertEqualEntries(env, ["FOO=", "BAR=foo"])
+
+        # Make sure modifications work
+        self.assertFalse(env.Set("FOO", "bar", overwrite=False))
+        self.assertEqual(env.Get("FOO"), "")
+
+        env.PutEntry("FOO=bar")
+        self.assertEqual(env.Get("FOO"), "bar")
+
+        self.assertEqualEntries(env, ["FOO=bar", "BAR=foo"])
+
+        # Make sure we can unset
+        self.assertTrue(env.Unset("FOO"))
+        self.assertFalse(env.Unset("FOO"))
+        self.assertEqual(env.Get("FOO"), None)
+
+        # Test SetEntries
+        entries = lldb.SBStringList()
+        entries.AppendList(["X=x", "Y=y"], 2)
+
+        env.SetEntries(entries, append=True)
+        self.assertEqualEntries(env, ["BAR=foo", "X=x", "Y=y"])
+
+        env.SetEntries(entries, append=False)
+        self.assertEqualEntries(env, ["X=x", "Y=y"])
+
+        # Test clear
+        env.Clear()
+        self.assertEqualEntries(env, [])