Implement GetSharedLibraryInfoAddress

[aadsm]

Summary

This is the third patch to improve module loading in a series that started here (where I explain the motivation and solution): D62499

Add functions to read the r_debug location to know where the linked list of loaded libraries are so I can generate the xfer:libraries-svr4 packet.
I'm also using this function to implement GetSharedLibraryInfoAddress that was "not implemented" for linux.
Most of this code was inspired by the current ds2 implementation here: https://github.com/facebook/ds2/blob/master/Sources/Target/POSIX/ELFProcess.cpp.

[labath]

Looks relatively straight-forward, but I'll wait with the full review of this and subsequent patches until we sort out the first two patches in this series.

[aadsm]

Rebase

[aadsm]

Rebase

[clayborg]

lldb/include/lldb/Host/common/NativeProcessProtocol.h

430 ↗

(On Diff #202651)

This doesn't seem like it belongs in the base class. Maybe just add it to NativeProcessLinux.h?

[aadsm]

lldb/include/lldb/Host/common/NativeProcessProtocol.h

430 ↗

(On Diff #202651)

oops, it certainly does not, my mistake.

[aadsm]

Address comments

[labath]

+@mgorny, @krytarowski in case they know anything interesting about dynamic linkers.

NativeProcessProtocol is certainly too generic for this sort of thing, but perhaps it would make sense to put this in a slightly more generic place? After all, this approach should work on all elf platforms, right? So maybe we could create a (for lack of a better name) NativeProcessELF class to hold these kinds of things. You could just make NativeProcessLinux inherit from that, and the NetBSD folks can migrate NativeProcessNetBSD once they test things out. IIRC there are other things which could be shared between NativeProcessLinux and NetBSD that could be moved here in the future.

Another advantage of having this in an abstract class is that you could test this in isolation, as NativeProcessProtocol is already setup to mock memory accesses: https://github.com/llvm-mirror/lldb/blob/master/unittests/Host/NativeProcessProtocolTest.cpp.

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

1392–1393

I'd put handling of the caching into this function, simply because the other one is already busy with plenty of other things. Also it would be nicer if the member variable was an Optional<addr_t>.

2098

This innocent-looking line assumes that the program headers will be the very next thing coming after the elf header, and that the elf header will be contained in the lowest-located segment. Although they are usually true, neither of the two assumptions are really guaranteed. I spent a bunch of time figuring out if there's a way to avoid that, but I haven't come up with anything... :/

2112

Are you sure that ReadMemory doesn't return "success" on partial reads too ?

2144

The address of r_debug shouldn't ever change, right?
Wouldn't it be better return &r_debug directly, instead of returning a pointer to a pointer?

[aadsm]

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

2112

We correctly return a non-success response if ptrace failed. However, from what I could see ptrace was successfully reading 0's when the memory segment was not readable for instance. I'm not concern if we're reading 0's if the segment is not readable, or should I be?

2144

It should not change but it might not be initialized yet. But the big reason is because GetSharedLibraryInfoAddress should return (which I'm planning to hook up to qShlibInfoAddr) the address of where the debug structure pointer is.
At least that's what I gather from reading the ResolveRendezvousAddress function, the documentation is not 100% clear (imho).

[aadsm]

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

2098

Ah, I thought that was always true. I checked gdb and they're actually using the PT_PHDR entry (which gives the location of the program table itself) to calculate the relocation. We should probably do the same.

[labath]

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

2098

Ah, of course. So, the load bias could be calculated as the difference between the PHDR address we got from the aux vector and the address that is contained in the phdr itself. That's really neat. :)

2112

We correctly return a non-success response if ptrace failed.

Hmm... that's odd. I had a feeling most of our read-like functions return "success" if they got at least some data. But, anyway, that's not your problem.

However, from what I could see ptrace was successfully reading 0's when the memory segment was not readable for instance. I'm not concern if we're reading 0's if the segment is not readable, or should I be?

By, "not readable", you mean mapped into process memory, but without a read permission (e.g., mmap(..., PROT_NONE)). In this case, I don't think it will return zero, but it will actually ignore the read permission and just return whatever is the actual contents of the memory.

However, I don't think we have to worry about that. I was mainly worried that ReadMemory will not fill in the phdr_entry struct and that we will later access uninitialized memory (sounding all kinds of asan warnings and stuff). The fact that ReadMemory may return incorrect data is something we have to be prepared to handle anyway, as we cannot really trust the application to provide the correct data here.

2144

Ok, sounds good then.

[aadsm]

Another advantage of having this in an abstract class is that you could test this in isolation, as NativeProcessProtocol is already setup to mock memory accesses: https://github.com/llvm-mirror/lldb/blob/master/unittests/Host/NativeProcessProtocolTest.cpp.

I might be missing something here, I'm not sure how having this in a NativeProcessELF class instead of NativeProcessLinux would make things easier for testing. Like you said, NativeProcessProtocol is the one set up to mock memory access. I still need to create my own MockProcessELF, which makes me think if there's a way to somehow reuse MockProcess to create MockProcessELF?

[labath]

In D62501#1531202, @aadsm wrote:

Another advantage of having this in an abstract class is that you could test this in isolation, as NativeProcessProtocol is already setup to mock memory accesses: https://github.com/llvm-mirror/lldb/blob/master/unittests/Host/NativeProcessProtocolTest.cpp.

I might be missing something here, I'm not sure how having this in a NativeProcessELF class instead of NativeProcessLinux would make things easier for testing. Like you said, NativeProcessProtocol is the one set up to mock memory access. I still need to create my own MockProcessELF, which makes me think if there's a way to somehow reuse MockProcess to create MockProcessELF?

Yeah, sorry, I guess that came out more optimistic then what I meant. What I was trying to say, that it is possible to create NativeProcessProtocol in a unit test, which means it would be also possible for the NativeProcessELF.

I haven't given this much thought, but it may be possible to reuse the stuff in MockProcess by making it a template (so you'd have a MockProcess<NativeProcessProtocol>, and a MockProcess<NativeProcessELF>)

[aadsm]

I haven't given this much thought, but it may be possible to reuse the stuff in MockProcess by making it a template (so you'd have a MockProcess<NativeProcessProtocol>, and a MockProcess<NativeProcessELF>)

Ah interesting, will explore that instead. I was actually thinking if it would be possible to extract the common stuff into a MockProcessCommon and then use multiple inheritance like MockProcess : MockProcessCommon, NativeProcessProtocol and MockProcessELF : MockProcessCommon, NativeProcessELF but I don't know much about C++ to know if it's feasible so I'll just need to try, it will be a good learning experience.

[aadsm]

@labath while working on this I had to also move the GetAuxValue function into the NativeProcessELF, which I think it's fine. However, this means this class now depends on the AuxValue class defined in the PluginUtility. Initially I was going to put the NativeProcessELF in the lldbHost but it feels weird that this will now depend on a plugin, even if it's the utility one. Should I create a new ELF plugin just for this?

[labath]

In D62501#1531959, @aadsm wrote:

@labath while working on this I had to also move the GetAuxValue function into the NativeProcessELF, which I think it's fine. However, this means this class now depends on the AuxValue class defined in the PluginUtility. Initially I was going to put the NativeProcessELF in the lldbHost but it feels weird that this will now depend on a plugin, even if it's the utility one. Should I create a new ELF plugin just for this?

Yeah, having Host depend on Process/Utility would be suboptimal, as we've just spend a lot of time making sure Host does not depend on anything. I would be fine with creating a new plugin for this. A couple of other possible solutions I see are:

• put this in Plugins/Process/POSIX: These days, the folder is mostly empty, so we could start repurposing it for this. Having an "ELF" process inside "POSIX" folder looks a bit weird, but my reasoning behind that is that we will probably one day need a NativeProcessPOSIX to share the common code between non-elf posix platform (i.e. darwin). Then NativeProcessELF would be a refinement (subclass) of NativeProcessPOSIX
• move all Native***Protocol classes out of Host into some new place. This is pretty specialized code, and I don't think it needs to live in a relatively general place. At that point it becomes less important to have to outgoing dependencies here.
• make the rendezvous structure parser a "utility" too. All this needs to function is the aux vector and something to read the memory with. You could provide these as arguments to its constructor. This way we won't need a NativeProcessELF, side-stepping the issue of where to place it. Additionally, this would open the door for using this code on the client side. Right now, DynamicLoaderPOSIXDYLD plugin has it's own code for parsing this structure, but I don't see a reason why this code couldn't be used there too. It would also solve the testing problems, as you'd just need to mock these two things (auxv, memory), and not the full NativeProcessProtocol API.

When I spell things out this way, I think I'm starting to prefer the last option. Let me know what you think.

[aadsm]

Interesting, I actually don't think there's much to gain from turning this into an utility. Creating a NativeProcessELF makes sense to me (I already did it and have all the tests up and running as well) and putting it into POSIX also makes sense to me based on what you said.

The big motivation I can see with an utility would be to share the logic between client and server but in this particular situation I don't think that's an advantage.
If you look at DYLDRendezvous we don't read the image info address there, this is done by the process, which in turn will actually use gdb server to get this data otherwise it will use the structures it already has parsed (the image section etc.) to access this.

The other part is to read the libraries' linked list. If we used a common function for this it would force us to create an interface to read memory making both client and server go for a common denominator that might not be optimal for neither of them.
I'm usually a bit wary of trying to generalize so much because of this. For example, today on the server we do a single read for the entire link_map structure and on the client we perform 5 ReadPointers.
Fwiw, I did think about this at the beginning (just like I did for the AuxVector, but that one is different because it's just parsing a block of data) and that was the reason why I didn't pursue it.

Having said this, I am a bit biased just because I've already implemented the NativeProcessELF solution and have very little cycles left to work on this (was hoping to land this week :D), but I do believe that having this on NativeProcess* will be better.

PS: I like your 2) point and it makes sense to me as well but I think that would be outside the scope of this stack of diffs (I'd be happy to work on this in the future).

[labath]

Ok, makes sense, I'm happy that you've considered the dynamic loader sharing tradeoffs already. Let's go with the NativeProcessELF thingy then.

[aadsm]

This creates a NativeProcessELF to deal with ELF specific things. The NativeProcessLinux now extends this one.
Added a test case for the GetAuxValue and GetELFImageInfoAddress. I refactored NativeProcessTestUtils to reuse that code.
I also addressed other comments on the review.

Note about the tests: I only have one test for the GetELFImageInfoAddress that follows the 32bit version and also makes sure we correctly read the load bias. Tbh I'm not sure if this is enough but should be easy to add more cases now.

[labath]

I think this is pretty good now. The only concern I have is about the placement NativeProcessTestUtils. The way you're including it now looks weird. I think we should put that in a separate place, as per the inline coment.

In D62501#1533483, @aadsm wrote:

Note about the tests: I only have one test for the GetELFImageInfoAddress that follows the 32bit version and also makes sure we correctly read the load bias. Tbh I'm not sure if this is enough but should be easy to add more cases now.

The main advantage of this kind of tests I see is that they make it possible to test what happens if things don't go as expected. You don't have to go overboard on that (you've already done a lot more here than most other code reviews do), but it may be nice to include one test where this lookup fails (e.g. the DT_DEBUG entry is missing, or something).

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

41

I guess this is no longer needed.

lldb/unittests/Process/POSIX/NativeProcessELFTest.cpp

9

This is the second time we've needed to share code between various unit tests. Let's just try start a convention for putting these into a separate place and see how it develops. I'd say we should put this into unittests/TestingSupport/Host/NativeProcessTestUtils.h (so, #includable as "TestingSupport/Host/NativeProcessTestUtils.h"), for the time being.

35

s/vector/ArrayRef

45–46

you could say toStringRef(buffer_sp->GetData())

61–64

Optional has overloaded equality operators which "do the right thing", though they are a bit tricky to use with integral types, as they kick in only if the contained type matches exactly. If you changed the type of phdr_addr to uint64_t, then you could just write ASSERT_EQ(phdr_addr, process.GetAuxValue(AuxVector::AUXV_AT_PHDR)) here.

83–117

What if we just defined a struct which described the final memory layout, and then gave that as an argument to the FakeMemory object?

I'm thinking of something like:

struct MemoryContents {
  Elf32_Phdr phdr_load;
  Elf32_Phdr phdr_dynamic;
  Elf32_Dyn dyn_debug;
} MC;
MC.phdr_load.p_type = PT_DYNAMIC;
...
FakeMemory M(&MC, sizeof MC, phdr_addr); // This assumes adding a (const void *, size_t) constructor to the class

[aadsm]

Address comments

[aadsm]

Removed unwanted change

[labath]

LGTM.

BTW, I see you still haven't submitted the previous two changes in the stack. Are you planning to submit all of them together or what? It's usually better to avoid batch submitting a bunch of dependent changes, as that way, if any problem shows up with the first one, the whole stack needs to be reverted

[aadsm]

Initially one at a time but then thought it might be better to do it as a batch because I was afraid I was missing some dependency and would brake something unexpectedly. But I guess that since I've already landed D62168 it's probably fine to land one at a time.

lldb/unittests/Process/POSIX/NativeProcessELFTest.cpp

83–117

Ah nice, why didn't I think about this before :D

[aadsm]

Improve tests

lldb/source/Plugins/Process/Linux/NativeProcessLinux.h

 //===-- NativeProcessLinux.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 liblldb_NativeProcessLinux_H_
 #define liblldb_NativeProcessLinux_H_
 
 #include <csignal>
 #include <unordered_set>
 
-#include "Plugins/Process/Utility/AuxVector.h"
 #include "lldb/Host/Debug.h"
 #include "lldb/Host/HostThread.h"
 #include "lldb/Host/linux/Support.h"
 #include "lldb/Target/MemoryRegionInfo.h"
 #include "lldb/Utility/ArchSpec.h"
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/lldb-types.h"
 
 #include "NativeThreadLinux.h"
+#include "Plugins/Process/POSIX/NativeProcessELF.h"
 #include "ProcessorTrace.h"
-#include "lldb/Host/common/NativeProcessProtocol.h"
 
 namespace lldb_private {
 class Status;
 class Scalar;
 
 namespace process_linux {
 /// \class NativeProcessLinux
 /// Manages communication with the inferior (debugee) process.
 ///
 /// Upon construction, this class prepares and launches an inferior process
 /// for debugging.
 ///
 /// Changes in the inferior process state are broadcasted.
-class NativeProcessLinux : public NativeProcessProtocol {
+class NativeProcessLinux : public NativeProcessELF {
 public:
   class Factory : public NativeProcessProtocol::Factory {
   public:
     llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
     Launch(ProcessLaunchInfo &launch_info, NativeDelegate &native_delegate,
            MainLoop &mainloop) const override;
 
     llvm::Expected<std::unique_ptr<NativeProcessProtocol>>
public:
   Status WriteMemory(lldb::addr_t addr, const void *buf, size_t size,
                      size_t &bytes_written) override;
 
   Status AllocateMemory(size_t size, uint32_t permissions,
                         lldb::addr_t &addr) override;
 
   Status DeallocateMemory(lldb::addr_t addr) override;
 
-  lldb::addr_t GetSharedLibraryInfoAddress() override;
-
   size_t UpdateThreads() override;
 
   const ArchSpec &GetArchitecture() const override { return m_arch; }
 
   Status SetBreakpoint(lldb::addr_t addr, uint32_t size,
                        bool hardware) override;
 
   Status RemoveBreakpoint(lldb::addr_t addr, bool hardware = false) override;
 
   void DoStopIDBumped(uint32_t newBumpId) override;
 
   Status GetLoadedModuleFileSpec(const char *module_path,
                                  FileSpec &file_spec) override;
 
   Status GetFileLoadAddress(const llvm::StringRef &file_name,
                             lldb::addr_t &load_addr) override;
 
   NativeThreadLinux *GetThreadByID(lldb::tid_t id);
 
   llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
   GetAuxvData() const override {
     return getProcFile(GetID(), "auxv");
   }
 
-  llvm::Optional<uint64_t> GetAuxValue(enum AuxVector::EntryType type);
-
   lldb::user_id_t StartTrace(const TraceOptions &config,
                              Status &error) override;
 
   Status StopTrace(lldb::user_id_t traceid,
                    lldb::tid_t thread) override;
 
   Status GetData(lldb::user_id_t traceid, lldb::tid_t thread,
                  llvm::MutableArrayRef<uint8_t> &buffer,

 
 protected:
   llvm::Expected<llvm::ArrayRef<uint8_t>>
   GetSoftwareBreakpointTrapOpcode(size_t size_hint) override;
 
 private:
   MainLoop::SignalHandleUP m_sigchld_handle;
   ArchSpec m_arch;
-  std::unique_ptr<AuxVector> m_aux_vector;
 
   LazyBool m_supports_mem_region = eLazyBoolCalculate;
   std::vector<std::pair<MemoryRegionInfo, FileSpec>> m_mem_region_cache;
 
   lldb::tid_t m_pending_notification_tid = LLDB_INVALID_THREAD_ID;
 
   // List of thread ids stepping with a breakpoint with the address of
   // the relevan breakpoint

lldb/source/Plugins/Process/Linux/NativeProcessLinux.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/RegisterValue.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/StringExtractor.h"
+#include "llvm/BinaryFormat/ELF.h"
 #include "llvm/Support/Errno.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Threading.h"
 
 #include "NativeThreadLinux.h"
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/LinuxProcMaps.h"
 #include "Procfs.h"

 }
 
 // Public Instance Methods
 
 NativeProcessLinux::NativeProcessLinux(::pid_t pid, int terminal_fd,
                                        NativeDelegate &delegate,
                                        const ArchSpec &arch, MainLoop &mainloop,
                                        llvm::ArrayRef<::pid_t> tids)
-    : NativeProcessProtocol(pid, terminal_fd, delegate), m_arch(arch) {
+    : NativeProcessELF(pid, terminal_fd, delegate), m_arch(arch) {
   if (m_terminal_fd != -1) {
     Status status = EnsureFDFlags(m_terminal_fd, O_NONBLOCK);
     assert(status.Success());
   }
 
   Status status;
   m_sigchld_handle = mainloop.RegisterSignal(
       SIGCHLD, [this](MainLoopBase &) { SigchldHandler(); }, status);

 #endif
 }
 
 Status NativeProcessLinux::DeallocateMemory(lldb::addr_t addr) {
   // FIXME see comments in AllocateMemory - required lower-level
   // bits not in place yet (ThreadPlans)
   return Status("not implemented");
 }
 
-lldb::addr_t NativeProcessLinux::GetSharedLibraryInfoAddress() {
-  // punt on this for now
-  return LLDB_INVALID_ADDRESS;
-}
-
 size_t NativeProcessLinux::UpdateThreads() {
   // The NativeProcessLinux monitoring threads are always up to date with
   // respect to thread state and they keep the thread list populated properly.
   // All this method needs to do is return the thread count.
   return m_threads.size();
 }
 
 Status NativeProcessLinux::SetBreakpoint(lldb::addr_t addr, uint32_t size,
                                          bool hardware) {
if (traceid == m_pt_proces_trace_id) {
     // traceid maps to the whole process so we have to erase it from the thread
     // group.
     LLDB_LOG(log, "traceid maps to process");
     m_pt_traced_thread_group.erase(thread);
   }
   m_processor_trace_monitor.erase(iter);
 
   return error;
 }
-
-llvm::Optional<uint64_t>
-NativeProcessLinux::GetAuxValue(enum AuxVector::EntryType type) {
-  if (m_aux_vector == nullptr) {
-    auto buffer_or_error = GetAuxvData();
-    if (!buffer_or_error)
-      return llvm::None;
-    DataExtractor auxv_data(buffer_or_error.get()->getBufferStart(),
-                            buffer_or_error.get()->getBufferSize(),
-                            GetByteOrder(), GetAddressByteSize());
-    m_aux_vector = llvm::make_unique<AuxVector>(auxv_data);
-  }
-
-  return m_aux_vector->GetAuxValue(type);
-}

lldb/source/Plugins/Process/POSIX/CMakeLists.txt

 add_lldb_library(lldbPluginProcessPOSIX PLUGIN
   CrashReason.cpp
+  NativeProcessELF.cpp
   ProcessMessage.cpp
   ProcessPOSIXLog.cpp
 
   LINK_LIBS
+    lldbPluginProcessUtility
     lldbUtility
   LINK_COMPONENTS
     Support
   )

lldb/source/Plugins/Process/POSIX/NativeProcessELF.h

+//===-- NativeProcessELF.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 liblldb_NativeProcessELF_H_
+#define liblldb_NativeProcessELF_H_
+
+#include "Plugins/Process/Utility/AuxVector.h"
+#include "lldb/Host/common/NativeProcessProtocol.h"
+#include "llvm/BinaryFormat/ELF.h"
+
+namespace lldb_private {
+
+/// \class NativeProcessELF
+/// Abstract class that extends \a NativeProcessProtocol with ELF specific
+/// logic. Meant to be subclassed by ELF based NativeProcess* implementations.
+class NativeProcessELF : public NativeProcessProtocol {
+  using NativeProcessProtocol::NativeProcessProtocol;
+
+protected:
+  template <typename T> struct ELFLinkMap {
+    T l_addr;
+    T l_name;
+    T l_ld;
+    T l_next;
+    T l_prev;
+  };
+
+  llvm::Optional<uint64_t> GetAuxValue(enum AuxVector::EntryType type);
+
+  lldb::addr_t GetSharedLibraryInfoAddress() override;
+
+  template <typename ELF_EHDR, typename ELF_PHDR, typename ELF_DYN>
+  lldb::addr_t GetELFImageInfoAddress();
+
+  std::unique_ptr<AuxVector> m_aux_vector;
+  llvm::Optional<lldb::addr_t> m_shared_library_info_addr;
+};
+
+} // namespace lldb_private
+
+#endif
 No newline at end of file

lldb/source/Plugins/Process/POSIX/NativeProcessELF.cpp

+//===-- NativeProcessELF.cpp ---------------------------------- -*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "NativeProcessELF.h"
+
+#include "lldb/Utility/DataExtractor.h"
+
+namespace lldb_private {
+
+llvm::Optional<uint64_t>
+NativeProcessELF::GetAuxValue(enum AuxVector::EntryType type) {
+  if (m_aux_vector == nullptr) {
+    auto buffer_or_error = GetAuxvData();
+    if (!buffer_or_error)
+      return llvm::None;
+    DataExtractor auxv_data(buffer_or_error.get()->getBufferStart(),
+                            buffer_or_error.get()->getBufferSize(),
+                            GetByteOrder(), GetAddressByteSize());
+    m_aux_vector = llvm::make_unique<AuxVector>(auxv_data);
+  }
+
+  return m_aux_vector->GetAuxValue(type);
+}
+
+lldb::addr_t NativeProcessELF::GetSharedLibraryInfoAddress() {
+  if (!m_shared_library_info_addr.hasValue()) {
+    if (GetAddressByteSize() == 8)
+      m_shared_library_info_addr =
+          GetELFImageInfoAddress<llvm::ELF::Elf64_Ehdr, llvm::ELF::Elf64_Phdr,
+                                 llvm::ELF::Elf64_Dyn>();
+    else
+      m_shared_library_info_addr =
+          GetELFImageInfoAddress<llvm::ELF::Elf32_Ehdr, llvm::ELF::Elf32_Phdr,
+                                 llvm::ELF::Elf32_Dyn>();
+  }
+
+  return m_shared_library_info_addr.getValue();
+}
+
+template <typename ELF_EHDR, typename ELF_PHDR, typename ELF_DYN>
+lldb::addr_t NativeProcessELF::GetELFImageInfoAddress() {
+  llvm::Optional<uint64_t> maybe_phdr_addr =
+      GetAuxValue(AuxVector::AUXV_AT_PHDR);
+  llvm::Optional<uint64_t> maybe_phdr_entry_size =
+      GetAuxValue(AuxVector::AUXV_AT_PHENT);
+  llvm::Optional<uint64_t> maybe_phdr_num_entries =
+      GetAuxValue(AuxVector::AUXV_AT_PHNUM);
+  if (!maybe_phdr_addr || !maybe_phdr_entry_size || !maybe_phdr_num_entries)
+    return LLDB_INVALID_ADDRESS;
+  lldb::addr_t phdr_addr = *maybe_phdr_addr;
+  size_t phdr_entry_size = *maybe_phdr_entry_size;
+  size_t phdr_num_entries = *maybe_phdr_num_entries;
+
+  // Find the PT_DYNAMIC segment (.dynamic section) in the program header and
+  // what the load bias by calculating the difference of the program header
+  // load address and its virtual address.
+  lldb::offset_t load_bias;
+  bool found_load_bias = false;
+  lldb::addr_t dynamic_section_addr = 0;
+  uint64_t dynamic_section_size = 0;
+  bool found_dynamic_section = false;
+  ELF_PHDR phdr_entry;
+  for (size_t i = 0; i < phdr_num_entries; i++) {
+    size_t bytes_read;
+    auto error = ReadMemory(phdr_addr + i * phdr_entry_size, &phdr_entry,
+                            sizeof(phdr_entry), bytes_read);
+    if (!error.Success())
+      return LLDB_INVALID_ADDRESS;
+    if (phdr_entry.p_type == llvm::ELF::PT_PHDR) {
+      load_bias = phdr_addr - phdr_entry.p_vaddr;
+      found_load_bias = true;
+    }
+
+    if (phdr_entry.p_type == llvm::ELF::PT_DYNAMIC) {
+      dynamic_section_addr = phdr_entry.p_vaddr;
+      dynamic_section_size = phdr_entry.p_memsz;
+      found_dynamic_section = true;
+    }
+  }
+
+  if (!found_load_bias || !found_dynamic_section)
+    return LLDB_INVALID_ADDRESS;
+
+  // Find the DT_DEBUG entry in the .dynamic section
+  dynamic_section_addr += load_bias;
+  ELF_DYN dynamic_entry;
+  size_t dynamic_num_entries = dynamic_section_size / sizeof(dynamic_entry);
+  for (size_t i = 0; i < dynamic_num_entries; i++) {
+    size_t bytes_read;
+    auto error = ReadMemory(dynamic_section_addr + i * sizeof(dynamic_entry),
+                            &dynamic_entry, sizeof(dynamic_entry), bytes_read);
+    if (!error.Success())
+      return LLDB_INVALID_ADDRESS;
+    // Return the &DT_DEBUG->d_ptr which points to r_debug which contains the
+    // link_map.
+    if (dynamic_entry.d_tag == llvm::ELF::DT_DEBUG) {
+      return dynamic_section_addr + i * sizeof(dynamic_entry) +
+             sizeof(dynamic_entry.d_tag);
+    }
+  }
+
+  return LLDB_INVALID_ADDRESS;
+}
+
+} // namespace lldb_private
 No newline at end of file

lldb/unittests/Host/NativeProcessProtocolTest.cpp

 //===-- NativeProcessProtocolTest.cpp ---------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
+#include "NativeProcessTestUtils.h"
+
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "llvm/Testing/Support/Error.h"
 #include "gmock/gmock.h"
 
 using namespace lldb_private;
 using namespace lldb;
 using namespace testing;
 
-namespace {
-class MockDelegate : public NativeProcessProtocol::NativeDelegate {
-public:
-  MOCK_METHOD1(InitializeDelegate, void(NativeProcessProtocol *Process));
-  MOCK_METHOD2(ProcessStateChanged,
-               void(NativeProcessProtocol *Process, StateType State));
-  MOCK_METHOD1(DidExec, void(NativeProcessProtocol *Process));
-};
-
-// NB: This class doesn't use the override keyword to avoid
-// -Winconsistent-missing-override warnings from the compiler. The
-// inconsistency comes from the overriding definitions in the MOCK_*** macros.
-class MockProcess : public NativeProcessProtocol {
-public:
-  MockProcess(NativeDelegate &Delegate, const ArchSpec &Arch,
-              lldb::pid_t Pid = 1)
-      : NativeProcessProtocol(Pid, -1, Delegate), Arch(Arch) {}
-
-  MOCK_METHOD1(Resume, Status(const ResumeActionList &ResumeActions));
-  MOCK_METHOD0(Halt, Status());
-  MOCK_METHOD0(Detach, Status());
-  MOCK_METHOD1(Signal, Status(int Signo));
-  MOCK_METHOD0(Kill, Status());
-  MOCK_METHOD3(AllocateMemory,
-               Status(size_t Size, uint32_t Permissions, addr_t &Addr));
-  MOCK_METHOD1(DeallocateMemory, Status(addr_t Addr));
-  MOCK_METHOD0(GetSharedLibraryInfoAddress, addr_t());
-  MOCK_METHOD0(UpdateThreads, size_t());
-  MOCK_CONST_METHOD0(GetAuxvData,
-                     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>());
-  MOCK_METHOD2(GetLoadedModuleFileSpec,
-               Status(const char *ModulePath, FileSpec &Spec));
-  MOCK_METHOD2(GetFileLoadAddress,
-               Status(const llvm::StringRef &FileName, addr_t &Addr));
-
-  const ArchSpec &GetArchitecture() const /*override*/ { return Arch; }
-  Status SetBreakpoint(lldb::addr_t Addr, uint32_t Size,
-                       bool Hardware) /*override*/ {
-    if (Hardware)
-      return SetHardwareBreakpoint(Addr, Size);
-    else
-      return SetSoftwareBreakpoint(Addr, Size);
-  }
-
-  // Redirect base class Read/Write Memory methods to functions whose signatures
-  // are more mock-friendly.
-  Status ReadMemory(addr_t Addr, void *Buf, size_t Size,
-                    size_t &BytesRead) /*override*/;
-  Status WriteMemory(addr_t Addr, const void *Buf, size_t Size,
-                     size_t &BytesWritten) /*override*/;
-
-  MOCK_METHOD2(ReadMemory,
-               llvm::Expected<std::vector<uint8_t>>(addr_t Addr, size_t Size));
-  MOCK_METHOD2(WriteMemory,
-               llvm::Expected<size_t>(addr_t Addr,
-                                      llvm::ArrayRef<uint8_t> Data));
-
-  using NativeProcessProtocol::GetSoftwareBreakpointTrapOpcode;
-  llvm::Expected<std::vector<uint8_t>> ReadMemoryWithoutTrap(addr_t Addr,
-                                                             size_t Size);
-
-private:
-  ArchSpec Arch;
-};
-
-class FakeMemory {
-public:
-  FakeMemory(llvm::ArrayRef<uint8_t> Data) : Data(Data) {}
-  llvm::Expected<std::vector<uint8_t>> Read(addr_t Addr, size_t Size);
-  llvm::Expected<size_t> Write(addr_t Addr, llvm::ArrayRef<uint8_t> Chunk);
-
-private:
-  std::vector<uint8_t> Data;
-};
-} // namespace
-
-Status MockProcess::ReadMemory(addr_t Addr, void *Buf, size_t Size,
-                               size_t &BytesRead) {
-  auto ExpectedMemory = ReadMemory(Addr, Size);
-  if (!ExpectedMemory) {
-    BytesRead = 0;
-    return Status(ExpectedMemory.takeError());
-  }
-  BytesRead = ExpectedMemory->size();
-  assert(BytesRead <= Size);
-  std::memcpy(Buf, ExpectedMemory->data(), BytesRead);
-  return Status();
-}
-
-Status MockProcess::WriteMemory(addr_t Addr, const void *Buf, size_t Size,
-                                size_t &BytesWritten) {
-  auto ExpectedBytes = WriteMemory(
-      Addr, llvm::makeArrayRef(static_cast<const uint8_t *>(Buf), Size));
-  if (!ExpectedBytes) {
-    BytesWritten = 0;
-    return Status(ExpectedBytes.takeError());
-  }
-  BytesWritten = *ExpectedBytes;
-  return Status();
-}
-
-llvm::Expected<std::vector<uint8_t>>
-MockProcess::ReadMemoryWithoutTrap(addr_t Addr, size_t Size) {
-  std::vector<uint8_t> Data(Size, 0);
-  size_t BytesRead;
-  Status ST = NativeProcessProtocol::ReadMemoryWithoutTrap(
-      Addr, Data.data(), Data.size(), BytesRead);
-  if (ST.Fail())
-    return ST.ToError();
-  Data.resize(BytesRead);
-  return std::move(Data);
-}
-
-llvm::Expected<std::vector<uint8_t>> FakeMemory::Read(addr_t Addr,
-                                                      size_t Size) {
-  if (Addr >= Data.size())
-    return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                   "Address out of range.");
-  Size = std::min(Size, Data.size() - (size_t)Addr);
-  auto Begin = std::next(Data.begin(), Addr);
-  return std::vector<uint8_t>(Begin, std::next(Begin, Size));
-}
-
-llvm::Expected<size_t> FakeMemory::Write(addr_t Addr,
-                                         llvm::ArrayRef<uint8_t> Chunk) {
-  if (Addr >= Data.size())
-    return llvm::createStringError(llvm::inconvertibleErrorCode(),
-                                   "Address out of range.");
-  size_t Size = std::min(Chunk.size(), Data.size() - (size_t)Addr);
-  std::copy_n(Chunk.begin(), Size, &Data[Addr]);
-  return Size;
-}
-
 TEST(NativeProcessProtocolTest, SetBreakpoint) {
   NiceMock<MockDelegate> DummyDelegate;
-  MockProcess Process(DummyDelegate, ArchSpec("x86_64-pc-linux"));
+  MockProcess<NativeProcessProtocol> Process(DummyDelegate,
+                                             ArchSpec("x86_64-pc-linux"));
   auto Trap = cantFail(Process.GetSoftwareBreakpointTrapOpcode(1));
   InSequence S;
   EXPECT_CALL(Process, ReadMemory(0x47, 1))
       .WillOnce(Return(ByMove(std::vector<uint8_t>{0xbb})));
   EXPECT_CALL(Process, WriteMemory(0x47, Trap)).WillOnce(Return(ByMove(1)));
   EXPECT_CALL(Process, ReadMemory(0x47, 1)).WillOnce(Return(ByMove(Trap)));
   EXPECT_THAT_ERROR(Process.SetBreakpoint(0x47, 0, false).ToError(),
                     llvm::Succeeded());
 }
 
 TEST(NativeProcessProtocolTest, SetBreakpointFailRead) {
   NiceMock<MockDelegate> DummyDelegate;
-  MockProcess Process(DummyDelegate, ArchSpec("x86_64-pc-linux"));
+  MockProcess<NativeProcessProtocol> Process(DummyDelegate,
+                                             ArchSpec("x86_64-pc-linux"));
   EXPECT_CALL(Process, ReadMemory(0x47, 1))
       .WillOnce(Return(ByMove(
           llvm::createStringError(llvm::inconvertibleErrorCode(), "Foo"))));
   EXPECT_THAT_ERROR(Process.SetBreakpoint(0x47, 0, false).ToError(),
                     llvm::Failed());
 }
 
 TEST(NativeProcessProtocolTest, SetBreakpointFailWrite) {
   NiceMock<MockDelegate> DummyDelegate;
-  MockProcess Process(DummyDelegate, ArchSpec("x86_64-pc-linux"));
+  MockProcess<NativeProcessProtocol> Process(DummyDelegate,
+                                             ArchSpec("x86_64-pc-linux"));
   auto Trap = cantFail(Process.GetSoftwareBreakpointTrapOpcode(1));
   InSequence S;
   EXPECT_CALL(Process, ReadMemory(0x47, 1))
       .WillOnce(Return(ByMove(std::vector<uint8_t>{0xbb})));
   EXPECT_CALL(Process, WriteMemory(0x47, Trap))
       .WillOnce(Return(ByMove(
           llvm::createStringError(llvm::inconvertibleErrorCode(), "Foo"))));
   EXPECT_THAT_ERROR(Process.SetBreakpoint(0x47, 0, false).ToError(),
                     llvm::Failed());
 }
 
 TEST(NativeProcessProtocolTest, SetBreakpointFailVerify) {
   NiceMock<MockDelegate> DummyDelegate;
-  MockProcess Process(DummyDelegate, ArchSpec("x86_64-pc-linux"));
+  MockProcess<NativeProcessProtocol> Process(DummyDelegate,
+                                             ArchSpec("x86_64-pc-linux"));
   auto Trap = cantFail(Process.GetSoftwareBreakpointTrapOpcode(1));
   InSequence S;
   EXPECT_CALL(Process, ReadMemory(0x47, 1))
       .WillOnce(Return(ByMove(std::vector<uint8_t>{0xbb})));
   EXPECT_CALL(Process, WriteMemory(0x47, Trap)).WillOnce(Return(ByMove(1)));
   EXPECT_CALL(Process, ReadMemory(0x47, 1))
       .WillOnce(Return(ByMove(
           llvm::createStringError(llvm::inconvertibleErrorCode(), "Foo"))));
   EXPECT_THAT_ERROR(Process.SetBreakpoint(0x47, 0, false).ToError(),
                     llvm::Failed());
 }
 
 TEST(NativeProcessProtocolTest, ReadMemoryWithoutTrap) {
   NiceMock<MockDelegate> DummyDelegate;
-  MockProcess Process(DummyDelegate, ArchSpec("aarch64-pc-linux"));
+  MockProcess<NativeProcessProtocol> Process(DummyDelegate,
+                                             ArchSpec("aarch64-pc-linux"));
   FakeMemory M{{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}};
   EXPECT_CALL(Process, ReadMemory(_, _))
       .WillRepeatedly(Invoke(&M, &FakeMemory::Read));
   EXPECT_CALL(Process, WriteMemory(_, _))
       .WillRepeatedly(Invoke(&M, &FakeMemory::Write));
 
   EXPECT_THAT_ERROR(Process.SetBreakpoint(0x4, 0, false).ToError(),
                     llvm::Succeeded());

lldb/unittests/Host/NativeProcessTestUtils.h

+//===-- NativeProcessTestUtils.cpp ------------------------------*- 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_unittests_Host_NativeProcessTestUtils_h_
+#define lldb_unittests_Host_NativeProcessTestUtils_h_
+
+#include "lldb/Host/common/NativeProcessProtocol.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gmock/gmock.h"
+
+using namespace lldb_private;
+using namespace lldb;
+using namespace testing;
+
+namespace lldb_private {
+
+class MockDelegate : public NativeProcessProtocol::NativeDelegate {
+public:
+  MOCK_METHOD1(InitializeDelegate, void(NativeProcessProtocol *Process));
+  MOCK_METHOD2(ProcessStateChanged,
+               void(NativeProcessProtocol *Process, StateType State));
+  MOCK_METHOD1(DidExec, void(NativeProcessProtocol *Process));
+};
+
+// NB: This class doesn't use the override keyword to avoid
+// -Winconsistent-missing-override warnings from the compiler. The
+// inconsistency comes from the overriding definitions in the MOCK_*** macros.
+template <typename T> class MockProcess : public T {
+public:
+  MockProcess(NativeProcessProtocol::NativeDelegate &Delegate,
+              const ArchSpec &Arch, lldb::pid_t Pid = 1)
+      : T(Pid, -1, Delegate), Arch(Arch) {}
+
+  MOCK_METHOD1(Resume, Status(const ResumeActionList &ResumeActions));
+  MOCK_METHOD0(Halt, Status());
+  MOCK_METHOD0(Detach, Status());
+  MOCK_METHOD1(Signal, Status(int Signo));
+  MOCK_METHOD0(Kill, Status());
+  MOCK_METHOD3(AllocateMemory,
+               Status(size_t Size, uint32_t Permissions, addr_t &Addr));
+  MOCK_METHOD1(DeallocateMemory, Status(addr_t Addr));
+  MOCK_METHOD0(GetSharedLibraryInfoAddress, addr_t());
+  MOCK_METHOD0(UpdateThreads, size_t());
+  MOCK_CONST_METHOD0(GetAuxvData,
+                     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>());
+  MOCK_METHOD2(GetLoadedModuleFileSpec,
+               Status(const char *ModulePath, FileSpec &Spec));
+  MOCK_METHOD2(GetFileLoadAddress,
+               Status(const llvm::StringRef &FileName, addr_t &Addr));
+
+  const ArchSpec &GetArchitecture() const /*override*/ { return Arch; }
+  Status SetBreakpoint(lldb::addr_t Addr, uint32_t Size,
+                       bool Hardware) /*override*/ {
+    if (Hardware)
+      return this->SetHardwareBreakpoint(Addr, Size);
+    else
+      return this->SetSoftwareBreakpoint(Addr, Size);
+  }
+
+  // Redirect base class Read/Write Memory methods to functions whose signatures
+  // are more mock-friendly.
+  Status ReadMemory(addr_t Addr, void *Buf, size_t Size,
+                    size_t &BytesRead) /*override*/ {
+    auto ExpectedMemory = this->ReadMemory(Addr, Size);
+    if (!ExpectedMemory) {
+      BytesRead = 0;
+      return Status(ExpectedMemory.takeError());
+    }
+    BytesRead = ExpectedMemory->size();
+    assert(BytesRead <= Size);
+    std::memcpy(Buf, ExpectedMemory->data(), BytesRead);
+    return Status();
+  }
+
+  Status WriteMemory(addr_t Addr, const void *Buf, size_t Size,
+                     size_t &BytesWritten) /*override*/ {
+    auto ExpectedBytes = this->WriteMemory(
+        Addr, llvm::makeArrayRef(static_cast<const uint8_t *>(Buf), Size));
+    if (!ExpectedBytes) {
+      BytesWritten = 0;
+      return Status(ExpectedBytes.takeError());
+    }
+    BytesWritten = *ExpectedBytes;
+    return Status();
+  }
+
+  MOCK_METHOD2(ReadMemory,
+               llvm::Expected<std::vector<uint8_t>>(addr_t Addr, size_t Size));
+  MOCK_METHOD2(WriteMemory,
+               llvm::Expected<size_t>(addr_t Addr,
+                                      llvm::ArrayRef<uint8_t> Data));
+
+  using T::GetSoftwareBreakpointTrapOpcode;
+  llvm::Expected<std::vector<uint8_t>> ReadMemoryWithoutTrap(addr_t Addr,
+                                                             size_t Size) {
+    std::vector<uint8_t> Data(Size, 0);
+    size_t BytesRead;
+    Status ST =
+        T::ReadMemoryWithoutTrap(Addr, Data.data(), Data.size(), BytesRead);
+    if (ST.Fail())
+      return ST.ToError();
+    Data.resize(BytesRead);
+    return std::move(Data);
+  }
+
+private:
+  ArchSpec Arch;
+};
+
+class FakeMemory {
+public:
+  FakeMemory(llvm::ArrayRef<uint8_t> Data, addr_t start_addr = 0)
+      : Data(Data), m_start_addr(start_addr) {}
+
+  llvm::Expected<std::vector<uint8_t>> Read(addr_t Addr, size_t Size) {
+    Addr -= m_start_addr;
+    if (Addr >= Data.size())
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "Address out of range.");
+    Size = std::min(Size, Data.size() - (size_t)Addr);
+    auto Begin = std::next(Data.begin(), Addr);
+    return std::vector<uint8_t>(Begin, std::next(Begin, Size));
+  }
+
+  llvm::Expected<size_t> Write(addr_t Addr, llvm::ArrayRef<uint8_t> Chunk) {
+    Addr -= m_start_addr;
+    if (Addr >= Data.size())
+      return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                     "Address out of range.");
+    size_t Size = std::min(Chunk.size(), Data.size() - (size_t)Addr);
+    std::copy_n(Chunk.begin(), Size, &Data[Addr]);
+    return Size;
+  }
+
+private:
+  std::vector<uint8_t> Data;
+  addr_t m_start_addr;
+};
+} // namespace lldb_private
+
+#endif
 No newline at end of file

lldb/unittests/Process/CMakeLists.txt

 add_subdirectory(gdb-remote)
 if (CMAKE_SYSTEM_NAME MATCHES "Linux|Android")
   add_subdirectory(Linux)
+  add_subdirectory(POSIX)
 endif()
 add_subdirectory(minidump)

lldb/unittests/Process/POSIX/CMakeLists.txt

+include_directories(${LLDB_SOURCE_DIR}/source/Plugins/Process/POSIX)
+
+add_lldb_unittest(ProcessPOSIXTest
+  NativeProcessELFTest.cpp
+
+  LINK_LIBS
+    lldbPluginProcessPOSIX
+  )

lldb/unittests/Process/POSIX/NativeProcessELFTest.cpp

+//===-- NativeProcessELFTest.cpp --------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#include "../../Host/NativeProcessTestUtils.h"
+
+#include "Plugins/Process/POSIX/NativeProcessELF.h"
+#include "Plugins/Process/Utility/AuxVector.h"
+#include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/DataEncoder.h"
+#include "lldb/Utility/DataExtractor.h"
+#include "llvm/BinaryFormat/ELF.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Testing/Support/Error.h"
+#include "gmock/gmock.h"
+
+using namespace lldb_private;
+using namespace lldb;
+using namespace testing;
+
+namespace {
+class MockProcessELF : public MockProcess<NativeProcessELF> {
+public:
+  using MockProcess::MockProcess;
+  using NativeProcessELF::GetAuxValue;
+  using NativeProcessELF::GetELFImageInfoAddress;
+};
+
+std::unique_ptr<llvm::MemoryBuffer> CreateAuxvData(
+    MockProcessELF &process,
+    std::vector<std::pair<AuxVector::EntryType, uint32_t>> auxv_data) {
+  auto addr_size = process.GetAddressByteSize();
+  DataBufferSP buffer_sp(
+      new DataBufferHeap(auxv_data.size() * addr_size * 2, 0));
+  DataEncoder encoder(buffer_sp, process.GetByteOrder(), addr_size);
+  uint32_t offset = 0;
+  for (auto &pair : auxv_data) {
+    offset = encoder.PutAddress(offset, pair.first);
+    offset = encoder.PutAddress(offset, pair.second);
+  }
+  llvm::StringRef stringref((const char *)buffer_sp->GetBytes(),
+                            buffer_sp->GetByteSize());
+  return llvm::MemoryBuffer::getMemBufferCopy(stringref, "");
+}
+} // namespace
+
+TEST(NativeProcessELFTest, GetAuxValue) {
+  NiceMock<MockDelegate> DummyDelegate;
+  MockProcessELF process(DummyDelegate, ArchSpec("i386-pc-linux"));
+
+  uint32_t phdr_addr = 0x42;
+  auto auxv_buffer = CreateAuxvData(
+      process, {std::make_pair(AuxVector::AUXV_AT_PHDR, phdr_addr)});
+  EXPECT_CALL(process, GetAuxvData())
+      .WillOnce(Return(ByMove(std::move(auxv_buffer))));
+
+  llvm::Optional<uint64_t> maybe_phdr_addr =
+      process.GetAuxValue(AuxVector::AUXV_AT_PHDR);
+  ASSERT_NE(llvm::None, maybe_phdr_addr);
+  ASSERT_EQ(phdr_addr, *maybe_phdr_addr);
+}
+
+TEST(NativeProcessELFTest, GetELFImageInfoAddress) {
+  NiceMock<MockDelegate> DummyDelegate;
+  MockProcessELF process(DummyDelegate, ArchSpec("i386-pc-linux"));
+
+  uint32_t load_base = 0x1000;
+  uint32_t info_addr = 0x3741;
+  uint32_t phdr_addr = load_base + sizeof(llvm::ELF::Elf32_Ehdr);
+
+  auto auxv_buffer = CreateAuxvData(
+      process,
+      {std::make_pair(AuxVector::AUXV_AT_PHDR, phdr_addr),
+       std::make_pair(AuxVector::AUXV_AT_PHENT, sizeof(llvm::ELF::Elf32_Phdr)),
+       std::make_pair(AuxVector::AUXV_AT_PHNUM, 2)});
+  EXPECT_CALL(process, GetAuxvData())
+      .WillOnce(Return(ByMove(std::move(auxv_buffer))));
+
+  // We're going to set up a fake memory with 2 program headers and 1 entry in
+  // the dynamic section.
+  // For simplicity sake they will be consecutive in memory:
+  // +------------+
+  // | PT_PHDR    |
+  // +------------+
+  // | PT_DYNAMIC |
+  // +------------+
+  // | DT_DEBUG   |
+  // +------------+
+  uint8_t mem_data[2 * sizeof(llvm::ELF::Elf32_Phdr) +
+                   sizeof(llvm::ELF::Elf32_Dyn)];
+  DataEncoder mem_encoder((void *)&mem_data[0], sizeof(mem_data),
+                          process.GetByteOrder(), process.GetAddressByteSize());
+  uint32_t offset = 0;
+
+  llvm::ELF::Elf32_Phdr phdr_load;
+  llvm::ELF::Elf32_Phdr phdr_dynamic;
+  llvm::ELF::Elf32_Dyn dyn_debug;
+
+  // Setup the 2 program header entries
+  phdr_load.p_type = llvm::ELF::PT_PHDR;
+  phdr_load.p_vaddr = phdr_addr - load_base;
+  offset = mem_encoder.PutData(offset, &phdr_load, sizeof(phdr_load));
+
+  phdr_dynamic.p_type = llvm::ELF::PT_DYNAMIC;
+  phdr_dynamic.p_vaddr =
+      (phdr_addr + 2 * sizeof(llvm::ELF::Elf32_Phdr)) - load_base;
+  phdr_dynamic.p_memsz = sizeof(llvm::ELF::Elf32_Dyn);
+  offset = mem_encoder.PutData(offset, &phdr_dynamic, sizeof(phdr_dynamic));
+
+  // Setup the single entry in the .dynamic section
+  dyn_debug.d_tag = llvm::ELF::DT_DEBUG;
+  dyn_debug.d_un.d_ptr = info_addr;
+  mem_encoder.PutData(offset, &dyn_debug, sizeof(dyn_debug));
+
+  FakeMemory M(mem_data, phdr_addr);
+  EXPECT_CALL(process, ReadMemory(_, _))
+      .WillRepeatedly(Invoke(&M, &FakeMemory::Read));
+
+  lldb::addr_t elf_info_addr = process.GetELFImageInfoAddress<
+      llvm::ELF::Elf32_Ehdr, llvm::ELF::Elf32_Phdr, llvm::ELF::Elf32_Dyn>();
+
+  // Read the address at the elf_info_addr location to make sure we're reading
+  // the correct one.
+  DataExtractor mem_extractor(
+      mem_encoder.GetDataStart(), mem_encoder.GetByteSize(),
+      mem_encoder.GetByteOrder(), mem_encoder.GetAddressByteSize());
+  lldb::offset_t info_addr_offset = elf_info_addr - phdr_addr;
+  ASSERT_EQ(mem_extractor.GetAddress(&info_addr_offset), info_addr);
+}