Add support to read aux vector values

[aadsm]

Summary

This is the second patch to improve module loading in a series that started here (where I explain the motivation and solution): https://reviews.llvm.org/D62499

I need to read the aux vector to know where the r_debug map with the loaded libraries are.
The AuxVector class was made generic so it could be reused between the POSIX-DYLD plugin and NativeProcess*. The class itself ended up in the ProcessUtility plugin.

[labath]

Definitely go for the option of refactoring the DYLD AuxVector class to make it usable from lldb-server.

It doesn't look like it should be that complicated even. Instead of passing it a Process instance, we can just pass it the data we have obtained from the right process (liblldb process, or lldb-server process), along with any other data it needs to interpret it (looks like it's just the pointer size (?)).

The question of plugins depending on each other is just a matter of finding the right place to put this new class. In my mind, Plugins/Process/Utility` is not a real plugin, and I don't see much of a problem in the Posix dynamic loader depending on that (it makes sense that it would need *some* data about the process in order to do its job. Or, given that the new class will depend on just the data extractor and nothing else, we could put it all the way up to Utility.

A third option would be to create a completely new library for this. In the past we've talked about a new library for "classes describing various properties of a process", where we'd have MemoryRegionInfo, ProcessInfo, etc, but so far it hasn't materialized. It seems like this could fit nicely into this description, so we could start with the new library with this class. +@JDevlieghere for any thoughts on this.

[clayborg]

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

2091–2093

We need to get a copy of the data here right? I believe the "buffer_or_error" local variable will go out of scope and the data pointed to will be freed. You can use:

lldb::offset_t DataExtractor::CopyData(lldb::offset_t offset, lldb::offset_t length, void *dst) const;

which will copy of the data and internally own it in a DataBufferSP. Or you can create a DataBufferSP yourself using DataBufferHeap and placing it into a DataBufferSP and then passing that to the DataExtractor constructor or SetData method.

lldb/source/Plugins/Process/Utility/ELFAuxVector.cpp

18 ↗

(On Diff #201588)

data.GetAddress(offset_ptr);

lldb/source/Plugins/Process/Utility/ELFAuxVector.h

67 ↗

(On Diff #201588)

Is there only ever one entry in the AUXV map for each EntryType?

[clayborg]

I like this being in a Utility class like it is coded, but we should fix the POSIX DYLD plug-in to use this common code as part of this patch. Comments?

[aadsm]

lldb/source/Plugins/Process/Utility/ELFAuxVector.cpp

18 ↗

(On Diff #201588)

I know you pointed this out but I felt weird calling GetAddress since that's not the semantic value of the underlying data. That's why I still ended up with GetMaxU64, what do you think?

lldb/source/Plugins/Process/Utility/ELFAuxVector.h

67 ↗

(On Diff #201588)

Yes, this was something I was concerned with (since the AuxVector returns an iterator). I checked the "official" API and that's what they assume: http://man7.org/linux/man-pages/man3/getauxval.3.html

[clayborg]

lldb/source/Plugins/Process/Utility/ELFAuxVector.cpp

18 ↗

(On Diff #201588)

I would use it since that is exactly what you are doing with "data.GetMaxU64(offset_ptr, data.GetAddressByteSize());".

[JDevlieghere]

In D62500#1518815, @labath wrote:

Definitely go for the option of refactoring the DYLD AuxVector class to make it usable from lldb-server.

+1

It doesn't look like it should be that complicated even. Instead of passing it a Process instance, we can just pass it the data we have obtained from the right process (liblldb process, or lldb-server process), along with any other data it needs to interpret it (looks like it's just the pointer size (?)).

The question of plugins depending on each other is just a matter of finding the right place to put this new class. In my mind, Plugins/Process/Utility` is not a real plugin, and I don't see much of a problem in the Posix dynamic loader depending on that (it makes sense that it would need *some* data about the process in order to do its job. Or, given that the new class will depend on just the data extractor and nothing else, we could put it all the way up to Utility.

I don't think this is general enough to fit in Utility. Looking at other classes in Plugins/Process/Utility, it seems like a better fit.

A third option would be to create a completely new library for this. In the past we've talked about a new library for "classes describing various properties of a process", where we'd have MemoryRegionInfo, ProcessInfo, etc, but so far it hasn't materialized. It seems like this could fit nicely into this description, so we could start with the new library with this class. +@JDevlieghere for any thoughts on this.

Do you mean having AuxVector in this library, or having it take a ProcessInfo instead of the Process itself?

[labath]

In D62500#1519658, @JDevlieghere wrote:

A third option would be to create a completely new library for this. In the past we've talked about a new library for "classes describing various properties of a process", where we'd have MemoryRegionInfo, ProcessInfo, etc, but so far it hasn't materialized. It seems like this could fit nicely into this description, so we could start with the new library with this class. +@JDevlieghere for any thoughts on this.

Do you mean having AuxVector in this library, or having it take a ProcessInfo instead of the Process itself?

The first option. The idea would be that "ProcessInfo" describes uids/pids/... of a process, MemoryRegionInfo describes it's memory regions, and AuxVector describes it's, well.. aux vector. UnixSignals, and probably some others could go there too.

OTOH, Process/Utility sounds like a good name for this kind of thing, and some of these classes are already there, so we may want to approach this from the other end, and remove anything that should not be there (RegisterContextLLDB is my first candidate).

[aadsm]

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

2091–2093

Forgot to answer this, this is actually not needed because the ELFAuxVector copies what's given to it, it doesn't keep a a reference to the passed data.

[aadsm]

Rnamed ELFAuxVector to AuxVector and got rid of the one that existed in the POSIX-DYLD plugin.

[labath]

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp

38–43

It would be better to return an Optional<uint64_t> (or addr_t maybe ?) instead of using a magic value to mean "not found". It looks like at least some of these entries can validly be zero.

51–54

range-based for ?

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

91–94

It looks like we're not guarding the call to LoadModules on line 101, so I think we can assume that m_process is not null here (and I don't see why it should be -- it does not make sense to call DidAttach if there is no process around).

BTW, your guarding attempt isn't even correct as we'd always call m_process->GetByteOrder() and crash if the process was null.

181–184

same here.

548–549

Whitespace-only change. Did you maybe run clang-format on the whole file instead of just the diff?

It doesn't matter that much here as there isn't many of them, but I just want to make sure you're aware of this in the future.

[aadsm]

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp

38–43

Can do, I was trying to follow this api though: http://man7.org/linux/man-pages/man3/getauxval.3.html.
I think I'll go with the uint64_t though, I find it odd to return an addr_t because it's not an address, it's a number that happens to be the same size of an address.

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

91–94

oh no, this is embarrassing!

548–549

odd, pretty sure I just run clang-format-diff (as I don't have auto formatting going on), will double check this.

[labath]

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp

38–43

Ah, interesting. It's a bit odd of an api as it does not allow you to distinguish AT_EUID not being present from somebody actually being root. I guess you're expected to assume that the AT_EUID field will always be present...

In any case, I think it would be better to use Optional, and not be tied to what is expressible in some C api.

I'm fine with uint64_t.

[JDevlieghere]

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

94

llvm::make_unique< AuxVector>(auxv_data);

628–629

This shouldn't be auto anymore, as it's not obvious what the type is. Same below.

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

105

Newline before the function to keep things consistent.

[aadsm]

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

548–549

I have my editor to remove trailing spaces on save and this line had one, that's why it ended up being parsed by clang-format-diff.

[aadsm]

Address commentds

[aadsm]

Fix patch snafu

[aadsm]

Missing clang-format-diff

[labath]

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

629–638

if (llvm::Optional<uint64_t> vdso_base =
      m_auxv->GetAuxValue(AuxVector::AUXV_AT_SYSINFO_EHDR))
  m_vdso_base = *vdso_base;

(and similar elsewhere)

[clayborg]

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp

11

Not a big fan of constructors doing parsing work. No way to return an error unless you build that into the AuxVector class (AuxVector::GetError()).

13–20

Remove this function and just call "data.GetAddress(offset_ptr)"?

24–29

const size_t value_type_size = data.GetAddressByteSize() * 2;
while (data.ValidOffsetForDataOfSize(value_type_size)) {
  const uint64_t type = data.GetAddress(&offset);
  const uint64_t value = data.GetAddress(&offset);
  if (type == AUXV_AT_NULL)
    ...

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

91–94

We should change Process::GetAuxvData() to return a DataExtractor to avoid this kind of code.

94

Process can't be NULL ever in a DynamicLoader. It should be a reference, but there may have been complications making that happen for some reason since if you have a member variables "Process &m_process;" it has to be initialized in the contructor? Can't remember. Since process owns the dynamic loader plug-in you can assume "m_process" is always valid and not NULL.

181–184

We should change Process::GetAuxvData() to return a DataExtractor to avoid this kind of code.

183

Use std::move?

m_auxv = llvm::make_unique<AuxVector>(std::move(auxv_data));

[aadsm]

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp

11

That is true but ParseAuxv doesn't generate errors. It just reads as much data as it exists in the data extractor until there's no more.

[aadsm]

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

183

The constructor receives a lldb_private::DataExtractor & so there's no copy going on.

[aadsm]

Address comments

[aadsm]

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp

24–29

nice, this is a much better loop.

[clayborg]

Nice!

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

public:
   bool IsStepping() const { return m_state == lldb::eStateStepping; }
 
   bool CanResume() const { return m_state == lldb::eStateStopped; }
 
   lldb::ByteOrder GetByteOrder() const {
     return GetArchitecture().GetByteOrder();
   }
 
+  uint32_t GetAddressByteSize() const {
+    return GetArchitecture().GetAddressByteSize();
+  }
+
   virtual llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>>
   GetAuxvData() const = 0;
 
   // Exit Status
   virtual llvm::Optional<WaitStatus> GetExitStatus();
 
   virtual bool SetExitStatus(WaitStatus status, bool bNotifyStateChange);
 

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.h

-//===-- AuxVector.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_AuxVector_H_
-#define liblldb_AuxVector_H_
-
-#include <vector>
-
-#include "lldb/lldb-forward.h"
-
-namespace lldb_private {
-class DataExtractor;
-}
-
-/// \class AuxVector
-/// Represents a processes auxiliary vector.
-///
-/// When a process is loaded on Linux a vector of values is placed onto the
-/// stack communicating operating system specific information.  On
-/// construction this class locates and parses this information and provides a
-/// simple read-only interface to the entries found.
-class AuxVector {
-
-public:
-  AuxVector(lldb_private::Process *process);
-
-  struct Entry {
-    uint64_t type;
-    uint64_t value;
-
-    Entry() : type(0), value(0) {}
-  };
-
-  /// Constants describing the type of entry.
-  /// On Linux, running "LD_SHOW_AUXV=1 ./executable" will spew AUX
-  /// information. Added AUXV prefix to avoid potential conflicts with system-
-  /// defined macros
-  enum EntryType {
-    AUXV_AT_NULL = 0,            ///< End of auxv.
-    AUXV_AT_IGNORE = 1,          ///< Ignore entry.
-    AUXV_AT_EXECFD = 2,          ///< File descriptor of program.
-    AUXV_AT_PHDR = 3,            ///< Program headers.
-    AUXV_AT_PHENT = 4,           ///< Size of program header.
-    AUXV_AT_PHNUM = 5,           ///< Number of program headers.
-    AUXV_AT_PAGESZ = 6,          ///< Page size.
-    AUXV_AT_BASE = 7,            ///< Interpreter base address.
-    AUXV_AT_FLAGS = 8,           ///< Flags.
-    AUXV_AT_ENTRY = 9,           ///< Program entry point.
-    AUXV_AT_NOTELF = 10,         ///< Set if program is not an ELF.
-    AUXV_AT_UID = 11,            ///< UID.
-    AUXV_AT_EUID = 12,           ///< Effective UID.
-    AUXV_AT_GID = 13,            ///< GID.
-    AUXV_AT_EGID = 14,           ///< Effective GID.
-    AUXV_AT_CLKTCK = 17,         ///< Clock frequency (e.g. times(2)).
-    AUXV_AT_PLATFORM = 15,       ///< String identifying platform.
-    AUXV_AT_HWCAP = 16,          ///< Machine dependent hints about processor capabilities.
-    AUXV_AT_FPUCW = 18,          ///< Used FPU control word.
-    AUXV_AT_DCACHEBSIZE = 19,    ///< Data cache block size.
-    AUXV_AT_ICACHEBSIZE = 20,    ///< Instruction cache block size.
-    AUXV_AT_UCACHEBSIZE = 21,    ///< Unified cache block size.
-    AUXV_AT_IGNOREPPC = 22,      ///< Entry should be ignored.
-    AUXV_AT_SECURE = 23,         ///< Boolean, was exec setuid-like?
-    AUXV_AT_BASE_PLATFORM = 24,  ///< String identifying real platforms.
-    AUXV_AT_RANDOM = 25,         ///< Address of 16 random bytes.
-    AUXV_AT_EXECFN = 31,         ///< Filename of executable.
-    AUXV_AT_SYSINFO = 32,        ///< Pointer to the global system page used for system
-                                 ///calls and other nice things.
-    AUXV_AT_SYSINFO_EHDR = 33,
-    AUXV_AT_L1I_CACHESHAPE = 34, ///< Shapes of the caches.
-    AUXV_AT_L1D_CACHESHAPE = 35,
-    AUXV_AT_L2_CACHESHAPE = 36,
-    AUXV_AT_L3_CACHESHAPE = 37,
-  };
-
-private:
-  typedef std::vector<Entry> EntryVector;
-
-public:
-  typedef EntryVector::const_iterator iterator;
-
-  iterator begin() const { return m_auxv.begin(); }
-  iterator end() const { return m_auxv.end(); }
-
-  iterator FindEntry(EntryType type) const;
-
-  static const char *GetEntryName(const Entry &entry) {
-    return GetEntryName(static_cast<EntryType>(entry.type));
-  }
-
-  static const char *GetEntryName(EntryType type);
-
-  void DumpToLog(lldb_private::Log *log) const;
-
-private:
-  lldb_private::Process *m_process;
-  EntryVector m_auxv;
-
-  lldb::DataBufferSP GetAuxvData();
-
-  void ParseAuxv(lldb_private::DataExtractor &data);
-};
-
-#endif

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/AuxVector.cpp

 //===-- AuxVector.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 "AuxVector.h"
-#include "lldb/Target/Process.h"
-#include "lldb/Utility/DataBufferHeap.h"
-#include "lldb/Utility/DataExtractor.h"
-#include "lldb/Utility/Log.h"
 
-using namespace lldb;
-using namespace lldb_private;
+AuxVector::AuxVector(lldb_private::DataExtractor &data) { ParseAuxv(data); }
 
-static bool GetMaxU64(DataExtractor &data, lldb::offset_t *offset_ptr,
-                      uint64_t *value, unsigned int byte_size) {
+static bool ReadUInt(lldb_private::DataExtractor &data,
+                     lldb::offset_t *offset_ptr, uint64_t *value) {
   lldb::offset_t saved_offset = *offset_ptr;
-  *value = data.GetMaxU64(offset_ptr, byte_size);
+  // We're not reading an address but an int that could be 32 or 64 bit
+  // depending on the address size, which is what GetAddress does.
+  *value = data.GetAddress(offset_ptr);
   return *offset_ptr != saved_offset;
 }
 
-static bool ParseAuxvEntry(DataExtractor &data, AuxVector::Entry &entry,
-                           lldb::offset_t *offset_ptr, unsigned int byte_size) {
-  if (!GetMaxU64(data, offset_ptr, &entry.type, byte_size))
-    return false;
-
-  if (!GetMaxU64(data, offset_ptr, &entry.value, byte_size))
-    return false;
-
-  return true;
-}
-
-DataBufferSP AuxVector::GetAuxvData() {
-  if (m_process)
-    return m_process->GetAuxvData();
-  else
-    return DataBufferSP();
-}
-
-void AuxVector::ParseAuxv(DataExtractor &data) {
-  const unsigned int byte_size = m_process->GetAddressByteSize();
+void AuxVector::ParseAuxv(lldb_private::DataExtractor &data) {
   lldb::offset_t offset = 0;
-
-  for (;;) {
-    Entry entry;
-
-    if (!ParseAuxvEntry(data, entry, &offset, byte_size))
+  while (true) {
+    uint64_t type = 0;
+    uint64_t value = 0;
+    if (!ReadUInt(data, &offset, &type) || !ReadUInt(data, &offset, &value))
       break;
-
-    if (entry.type == AUXV_AT_NULL)
+    if (type == AUXV_AT_NULL)
       break;
-
-    if (entry.type == AUXV_AT_IGNORE)
+    if (type == AUXV_AT_IGNORE)
       continue;
 
-    m_auxv.push_back(entry);
-  }
-}
-
-AuxVector::AuxVector(Process *process) : m_process(process) {
-  DataExtractor data;
-  Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
-
-  data.SetData(GetAuxvData());
-  data.SetByteOrder(m_process->GetByteOrder());
-  data.SetAddressByteSize(m_process->GetAddressByteSize());
-
-  ParseAuxv(data);
-
-  if (log)
-    DumpToLog(log);
+    m_auxv_entries[type] = value;
   }
-
-AuxVector::iterator AuxVector::FindEntry(EntryType type) const {
-  for (iterator I = begin(); I != end(); ++I) {
-    if (I->type == static_cast<uint64_t>(type))
-      return I;
-  }
 
-  return end();
+llvm::Optional<uint64_t>
+AuxVector::GetAuxValue(enum EntryType entry_type) const {
+  auto it = m_auxv_entries.find(static_cast<uint64_t>(entry_type));
+  if (it != m_auxv_entries.end())
+    return it->second;
+  return llvm::None;
 }
 
-void AuxVector::DumpToLog(Log *log) const {
+void AuxVector::DumpToLog(lldb_private::Log *log) const {
   if (!log)
     return;
 
   log->PutCString("AuxVector: ");
-  for (iterator I = begin(); I != end(); ++I) {
-    log->Printf("   %s [%" PRIu64 "]: %" PRIx64, GetEntryName(*I), I->type,
-                I->value);
+  for (auto entry : m_auxv_entries) {
+    log->Printf("   %s [%" PRIu64 "]: %" PRIx64,
+                GetEntryName(static_cast<EntryType>(entry.first)), entry.first,
+                entry.second);
   }
 }
 
-const char *AuxVector::GetEntryName(EntryType type) {
+const char *AuxVector::GetEntryName(EntryType type) const {
   const char *name = "AT_???";
 
-#define ENTRY_NAME(_type) \
-  _type:                  \
+#define ENTRY_NAME(_type)                                                      \
+  _type:                                                                       \
   name = &#_type[5]
   switch (type) {
     case ENTRY_NAME(AUXV_AT_NULL);           break;
     case ENTRY_NAME(AUXV_AT_IGNORE);         break;
     case ENTRY_NAME(AUXV_AT_EXECFD);         break;
     case ENTRY_NAME(AUXV_AT_PHDR);           break;
     case ENTRY_NAME(AUXV_AT_PHENT);          break;
     case ENTRY_NAME(AUXV_AT_PHNUM);          break;

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/CMakeLists.txt

 add_lldb_library(lldbPluginDynamicLoaderPosixDYLD PLUGIN
-  AuxVector.cpp
   DYLDRendezvous.cpp
   DynamicLoaderPOSIXDYLD.cpp
 
   LINK_LIBS
     lldbBreakpoint
     lldbCore
     lldbHost
     lldbSymbol
     lldbTarget
     lldbPluginProcessElfCore
+    lldbPluginProcessUtility
   LINK_COMPONENTS
     Support
   )

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.h

 //===-- DynamicLoaderPOSIXDYLD.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_DynamicLoaderPOSIXDYLD_h_
 #define liblldb_DynamicLoaderPOSIXDYLD_h_
 
 #include <map>
 #include <memory>
 
 #include "DYLDRendezvous.h"
+#include "Plugins/Process/Utility/AuxVector.h"
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Target/DynamicLoader.h"
 
 class AuxVector;
 
 class DynamicLoaderPOSIXDYLD : public lldb_private::DynamicLoader {
 public:

lldb/source/Plugins/DynamicLoader/POSIX-DYLD/DynamicLoaderPOSIXDYLD.cpp

 //===-- DynamicLoaderPOSIXDYLD.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
 //
 //===----------------------------------------------------------------------===//
 
 // Main header include
 #include "DynamicLoaderPOSIXDYLD.h"
 
-#include "AuxVector.h"
-
 #include "lldb/Breakpoint/BreakpointLocation.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/MemoryRegionInfo.h"
DynamicLoaderPOSIXDYLD::~DynamicLoaderPOSIXDYLD() {
   }
 }
 
 void DynamicLoaderPOSIXDYLD::DidAttach() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
   if (log)
     log->Printf("DynamicLoaderPOSIXDYLD::%s() pid %" PRIu64, __FUNCTION__,
                 m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
-
-  m_auxv.reset(new AuxVector(m_process));
+  DataExtractor auxv_data(m_process->GetAuxvData(), m_process->GetByteOrder(),
+                          m_process->GetAddressByteSize());
+  m_auxv = llvm::make_unique<AuxVector>(auxv_data);
   if (log)
     log->Printf("DynamicLoaderPOSIXDYLD::%s pid %" PRIu64 " reloaded auxv data",
                 __FUNCTION__,
                 m_process ? m_process->GetID() : LLDB_INVALID_PROCESS_ID);
 
   // ask the process if it can load any of its own modules
   m_process->LoadModules();
 
   ModuleSP executable_sp = GetTargetExecutable();

 void DynamicLoaderPOSIXDYLD::DidLaunch() {
   Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_DYNAMIC_LOADER));
   if (log)
     log->Printf("DynamicLoaderPOSIXDYLD::%s()", __FUNCTION__);
 
   ModuleSP executable;
   addr_t load_offset;
 
-  m_auxv.reset(new AuxVector(m_process));
+  DataExtractor auxv_data(m_process->GetAuxvData(), m_process->GetByteOrder(),
+                          m_process->GetAddressByteSize());
+  m_auxv = llvm::make_unique<AuxVector>(auxv_data);
 
   executable = GetTargetExecutable();
   load_offset = ComputeLoadOffset();
   EvalSpecialModulesStatus();
 
   if (executable.get() && load_offset != LLDB_INVALID_ADDRESS) {
     ModuleList module_list;
     module_list.Append(executable);
     UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset, true);
if (status.Fail() || info.GetMapped() != MemoryRegionInfo::eYes ||
     LLDB_LOG(log, "Failed to get interpreter region info: {0}", status);
     return nullptr;
   }
 
   FileSpec file(info.GetName().GetCString());
   ModuleSpec module_spec(file, target.GetArchitecture());
 
   if (ModuleSP module_sp = target.GetOrCreateModule(module_spec, 
                                                     true /* notify */)) {
     UpdateLoadedSections(module_sp, LLDB_INVALID_ADDRESS, m_interpreter_base,
                          false);
     return module_sp;
   }
   return nullptr;
 }
 
 void DynamicLoaderPOSIXDYLD::LoadAllCurrentModules() {
   DYLDRendezvous::iterator I;
addr_t DynamicLoaderPOSIXDYLD::ComputeLoadOffset() {
 
   if (!file_entry.IsValid())
     return LLDB_INVALID_ADDRESS;
 
   m_load_offset = virt_entry - file_entry.GetFileAddress();
   return m_load_offset;
 }
 
 void DynamicLoaderPOSIXDYLD::EvalSpecialModulesStatus() {
-  auto I = m_auxv->FindEntry(AuxVector::AUXV_AT_SYSINFO_EHDR);
-  if (I != m_auxv->end() && I->value != 0)
-    m_vdso_base = I->value;
-
-  I = m_auxv->FindEntry(AuxVector::AUXV_AT_BASE);
-  if (I != m_auxv->end() && I->value != 0)
-    m_interpreter_base = I->value;
+  llvm::Optional<uint64_t> vdso_base =
+      m_auxv->GetAuxValue(AuxVector::AUXV_AT_SYSINFO_EHDR);
+  if (vdso_base)
+    m_vdso_base = *vdso_base;
+
+  llvm::Optional<uint64_t> interpreter_base =
+      m_auxv->GetAuxValue(AuxVector::AUXV_AT_BASE);
+  if (interpreter_base)
+    m_interpreter_base = *interpreter_base;
 }
 
 addr_t DynamicLoaderPOSIXDYLD::GetEntryPoint() {
   if (m_entry_point != LLDB_INVALID_ADDRESS)
     return m_entry_point;
 
   if (m_auxv == nullptr)
     return LLDB_INVALID_ADDRESS;
 
-  AuxVector::iterator I = m_auxv->FindEntry(AuxVector::AUXV_AT_ENTRY);
+  auto entry_point = m_auxv->GetAuxValue(AuxVector::AUXV_AT_ENTRY);
 
-  if (I == m_auxv->end())
+  if (entry_point == 0)
     return LLDB_INVALID_ADDRESS;
 
-  m_entry_point = static_cast<addr_t>(I->value);
+  m_entry_point = static_cast<addr_t>(entry_point);
 
   const ArchSpec &arch = m_process->GetTarget().GetArchitecture();
 
   // On ppc64, the entry point is actually a descriptor.  Dereference it.
   if (arch.GetMachine() == llvm::Triple::ppc64)
     m_entry_point = ReadUnsignedIntWithSizeInBytes(m_entry_point, 8);
 
   return m_entry_point;

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"
 
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

if (traceid == m_pt_proces_trace_id) {
     // 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/Utility/AuxVector.h

+//===-- AuxVector.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_AuxVector_H_
+#define liblldb_AuxVector_H_
+
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Log.h"
+#include <unordered_map>
+
+class AuxVector {
+
+public:
+  AuxVector(lldb_private::DataExtractor &data);
+
+  /// Constants describing the type of entry.
+  /// On Linux, running "LD_SHOW_AUXV=1 ./executable" will spew AUX
+  /// information. Added AUXV prefix to avoid potential conflicts with system-
+  /// defined macros
+  enum EntryType {
+    AUXV_AT_NULL = 0,      ///< End of auxv.
+    AUXV_AT_IGNORE = 1,    ///< Ignore entry.
+    AUXV_AT_EXECFD = 2,    ///< File descriptor of program.
+    AUXV_AT_PHDR = 3,      ///< Program headers.
+    AUXV_AT_PHENT = 4,     ///< Size of program header.
+    AUXV_AT_PHNUM = 5,     ///< Number of program headers.
+    AUXV_AT_PAGESZ = 6,    ///< Page size.
+    AUXV_AT_BASE = 7,      ///< Interpreter base address.
+    AUXV_AT_FLAGS = 8,     ///< Flags.
+    AUXV_AT_ENTRY = 9,     ///< Program entry point.
+    AUXV_AT_NOTELF = 10,   ///< Set if program is not an ELF.
+    AUXV_AT_UID = 11,      ///< UID.
+    AUXV_AT_EUID = 12,     ///< Effective UID.
+    AUXV_AT_GID = 13,      ///< GID.
+    AUXV_AT_EGID = 14,     ///< Effective GID.
+    AUXV_AT_CLKTCK = 17,   ///< Clock frequency (e.g. times(2)).
+    AUXV_AT_PLATFORM = 15, ///< String identifying platform.
+    AUXV_AT_HWCAP =
+        16, ///< Machine dependent hints about processor capabilities.
+    AUXV_AT_FPUCW = 18,         ///< Used FPU control word.
+    AUXV_AT_DCACHEBSIZE = 19,   ///< Data cache block size.
+    AUXV_AT_ICACHEBSIZE = 20,   ///< Instruction cache block size.
+    AUXV_AT_UCACHEBSIZE = 21,   ///< Unified cache block size.
+    AUXV_AT_IGNOREPPC = 22,     ///< Entry should be ignored.
+    AUXV_AT_SECURE = 23,        ///< Boolean, was exec setuid-like?
+    AUXV_AT_BASE_PLATFORM = 24, ///< String identifying real platforms.
+    AUXV_AT_RANDOM = 25,        ///< Address of 16 random bytes.
+    AUXV_AT_EXECFN = 31,        ///< Filename of executable.
+    AUXV_AT_SYSINFO = 32, ///< Pointer to the global system page used for system
+                          /// calls and other nice things.
+    AUXV_AT_SYSINFO_EHDR = 33,
+    AUXV_AT_L1I_CACHESHAPE = 34, ///< Shapes of the caches.
+    AUXV_AT_L1D_CACHESHAPE = 35,
+    AUXV_AT_L2_CACHESHAPE = 36,
+    AUXV_AT_L3_CACHESHAPE = 37,
+  };
+
+  llvm::Optional<uint64_t> GetAuxValue(enum EntryType entry_type) const;
+  void DumpToLog(lldb_private::Log *log) const;
+  const char *GetEntryName(EntryType type) const;
+
+private:
+  void ParseAuxv(lldb_private::DataExtractor &data);
+
+  std::unordered_map<uint64_t, uint64_t> m_auxv_entries;
+};
+
+#endif

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

 add_lldb_library(lldbPluginProcessUtility PLUGIN
+  AuxVector.cpp
   DynamicRegisterInfo.cpp
   FreeBSDSignals.cpp
   GDBRemoteSignals.cpp
   HistoryThread.cpp
   HistoryUnwind.cpp
   InferiorCallPOSIX.cpp
   LinuxProcMaps.cpp
   LinuxSignals.cpp