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/DynamicLoaderPOSIXDYLD.cpp

92–93

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.

180–181

same here.

545–546

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.

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

32–37

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.

45–48

range-based for ?

[aadsm]

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

92–93

oh no, this is embarrassing!

545–546

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

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

32–37

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.

[labath]

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

32–37

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

95

llvm::make_unique< AuxVector>(auxv_data);

626–628

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

545–546

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

630–633

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/DynamicLoaderPOSIXDYLD.cpp

92–93

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

93

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.

180–181

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

182

Use std::move?

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

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

10–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()).

10–11

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

17–25

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)
    ...

[aadsm]

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

10–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

182

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

[aadsm]

Address comments

[aadsm]

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

17–25

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/include/lldb/Target/Process.h

/// UnregisterNotificationCallbacks (const Notifications&)
   /// plug-in.
   virtual DynamicLoader *GetDynamicLoader();
 
   // Returns AUXV structure found in many ELF-based environments.
   //
   // The default action is to return an empty data buffer.
   //
   // \return
-  //    A data buffer containing the contents of the AUXV data.
-  virtual const lldb::DataBufferSP GetAuxvData();
+  //    A data extractor containing the contents of the AUXV data.
+  virtual DataExtractor GetAuxvData();
 
   /// Sometimes processes know how to retrieve and load shared libraries. This
   /// is normally done by DynamicLoader plug-ins, but sometimes the connection
   /// to the process allows retrieving this information. The dynamic loader
   /// plug-ins can use this function if they can't determine the current
   /// shared library load state.
   ///
   /// \return

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/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 = llvm::make_unique<AuxVector>(m_process->GetAuxvData());
 
-  m_auxv.reset(new AuxVector(m_process));
   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();
   ResolveExecutableModule(executable_sp);
 

 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));
+  m_auxv = llvm::make_unique<AuxVector>(m_process->GetAuxvData());
 
   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;
+  if (llvm::Optional<uint64_t> vdso_base =
+          m_auxv->GetAuxValue(AuxVector::AUXV_AT_SYSINFO_EHDR))
+    m_vdso_base = *vdso_base;
+
+  if (llvm::Optional<uint64_t> interpreter_base =
+          m_auxv->GetAuxValue(AuxVector::AUXV_AT_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);
-
-  if (I == m_auxv->end())
+  llvm::Optional<uint64_t> entry_point =
+      m_auxv->GetAuxValue(AuxVector::AUXV_AT_ENTRY);
+  if (!entry_point)
     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/FreeBSD/ProcessFreeBSD.h

public:
 
   virtual lldb::ByteOrder GetByteOrder() const;
 
   lldb::addr_t GetImageInfoAddress() override;
 
   size_t PutSTDIN(const char *buf, size_t len,
                   lldb_private::Status &error) override;
 
-  const lldb::DataBufferSP GetAuxvData() override;
+  const lldb_private::DataExtractor GetAuxvData() override;
 
   // ProcessFreeBSD internal API.
 
   /// Registers the given message with this process.
   virtual void SendMessage(const ProcessMessage &message);
 
   ProcessMonitor &GetMonitor() {
     assert(m_monitor);

lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

for (uint32_t i = 0; i < thread_count; ++i) {
     if (thread_state == eStateRunning || thread_state == eStateStepping) {
       is_running = true;
       break;
     }
   }
   return is_running;
 }
 
-const DataBufferSP ProcessFreeBSD::GetAuxvData() {
+lldb_private::DataExtractor ProcessFreeBSD::GetAuxvData() {
   // If we're the local platform, we can ask the host for auxv data.
   PlatformSP platform_sp = GetTarget().GetPlatform();
   assert(platform_sp && platform_sp->IsHost());
 
   int mib[4] = {CTL_KERN, KERN_PROC, KERN_PROC_AUXV, (int)m_process->GetID()};
   size_t auxv_size = AT_COUNT * sizeof(Elf_Auxinfo);
   DataBufferSP buf_sp(new DataBufferHeap(auxv_size, 0));
 
   if (::sysctl(mib, 4, buf_sp->GetBytes(), &auxv_size, NULL, 0) != 0) {
     perror("sysctl failed on auxv");
     buf_sp.reset();
   }
 
-  return buf_sp;
+  return DataExtractor(buf_sp, GetByteOrder(), GetAddressByteSize());
 }
 
 struct EmulatorBaton {
   ProcessFreeBSD *m_process;
   RegisterContext *m_reg_context;
 
   // eRegisterKindDWARF -> RegisterValue
   std::unordered_map<uint32_t, RegisterValue> m_register_values;

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(const 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(const lldb_private::DataExtractor &data);
+
+  std::unordered_map<uint64_t, uint64_t> m_auxv_entries;
+};
+
+#endif

lldb/source/Plugins/Process/Utility/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;
-
-static bool GetMaxU64(DataExtractor &data, lldb::offset_t *offset_ptr,
-                      uint64_t *value, unsigned int byte_size) {
-  lldb::offset_t saved_offset = *offset_ptr;
-  *value = data.GetMaxU64(offset_ptr, byte_size);
-  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();
+AuxVector::AuxVector(const lldb_private::DataExtractor &data) {
+  ParseAuxv(data);
 }
 
-void AuxVector::ParseAuxv(DataExtractor &data) {
-  const unsigned int byte_size = m_process->GetAddressByteSize();
+void AuxVector::ParseAuxv(const lldb_private::DataExtractor &data) {
   lldb::offset_t offset = 0;
-
-  for (;;) {
-    Entry entry;
-
-    if (!ParseAuxvEntry(data, entry, &offset, byte_size))
+  const size_t value_type_size = data.GetAddressByteSize() * 2;
+  while (data.ValidOffsetForDataOfSize(offset, value_type_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.
+    const uint64_t type = data.GetAddress(&offset);
+    const uint64_t value = data.GetAddress(&offset);
+    if (type == AUXV_AT_NULL)
       break;
-
-    if (entry.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/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

lldb/source/Plugins/Process/elf-core/ProcessElfCore.h

public:
   GetMemoryRegionInfo(lldb::addr_t load_addr,
                       lldb_private::MemoryRegionInfo &region_info) override;
 
   lldb::addr_t GetImageInfoAddress() override;
 
   lldb_private::ArchSpec GetArchitecture();
 
   // Returns AUXV structure found in the core file
-  const lldb::DataBufferSP GetAuxvData() override;
+  lldb_private::DataExtractor GetAuxvData() override;
 
   bool GetProcessInfo(lldb_private::ProcessInstanceInfo &info) override;
 
 protected:
   void Clear();
 
   bool UpdateThreadList(lldb_private::ThreadList &old_thread_list,
                         lldb_private::ThreadList &new_thread_list) override;

lldb/source/Plugins/Process/elf-core/ProcessElfCore.cpp

ArchSpec ProcessElfCore::GetArchitecture() {
   // fail back to unconditionally returning the target arch in this config.
   if (target_arch.IsMIPS()) {
     return target_arch;
   }
 
   return arch;
 }
 
-const lldb::DataBufferSP ProcessElfCore::GetAuxvData() {
+DataExtractor ProcessElfCore::GetAuxvData() {
   const uint8_t *start = m_auxv.GetDataStart();
   size_t len = m_auxv.GetByteSize();
   lldb::DataBufferSP buffer(new lldb_private::DataBufferHeap(start, len));
-  return buffer;
+  return DataExtractor(buffer, GetByteOrder(), GetAddressByteSize());
 }
 
 bool ProcessElfCore::GetProcessInfo(ProcessInstanceInfo &info) {
   info.Clear();
   info.SetProcessID(GetID());
   info.SetArchitecture(GetArchitecture());
   lldb::ModuleSP module_sp = GetTarget().GetExecutableModule();
   if (module_sp) {
     const bool add_exe_file_as_first_arg = false;
     info.SetExecutableFile(GetTarget().GetExecutableModule()->GetFileSpec(),
                            add_exe_file_as_first_arg);
   }
   return true;
 }

lldb/source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

protected:
   void KillDebugserverProcess();
 
   void BuildDynamicRegisterInfo(bool force);
 
   void SetLastStopPacket(const StringExtractorGDBRemote &response);
 
   bool ParsePythonTargetDefinition(const FileSpec &target_definition_fspec);
 
-  const lldb::DataBufferSP GetAuxvData() override;
+  DataExtractor GetAuxvData() override;
 
   StructuredData::ObjectSP GetExtendedInfoForThread(lldb::tid_t tid);
 
   void GetMaxMemorySize();
 
   bool CalculateThreadStopInfo(ThreadGDBRemote *thread);
 
   size_t UpdateThreadPCsFromStopReplyThreadsValue(std::string &value);

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

if (!was_supported)
       error.SetErrorString("Sending events is not supported for this process.");
     else
       error.SetErrorStringWithFormat("Error sending event data: %d.",
                                      return_value);
   }
   return error;
 }
 
-const DataBufferSP ProcessGDBRemote::GetAuxvData() {
+DataExtractor ProcessGDBRemote::GetAuxvData() {
   DataBufferSP buf;
   if (m_gdb_comm.GetQXferAuxvReadSupported()) {
     std::string response_string;
     if (m_gdb_comm.SendPacketsAndConcatenateResponses("qXfer:auxv:read::",
                                                       response_string) ==
         GDBRemoteCommunication::PacketResult::Success)
       buf = std::make_shared<DataBufferHeap>(response_string.c_str(),
                                              response_string.length());
   }
-  return buf;
+  return DataExtractor(buf, GetByteOrder(), GetAddressByteSize());
 }
 
 StructuredData::ObjectSP
 ProcessGDBRemote::GetExtendedInfoForThread(lldb::tid_t tid) {
   StructuredData::ObjectSP object_sp;
 
   if (m_gdb_comm.GetThreadExtendedInfoSupported()) {
     StructuredData::ObjectSP args_dict(new StructuredData::Dictionary());

lldb/source/Target/Process.cpp

 }
 
 DynamicLoader *Process::GetDynamicLoader() {
   if (!m_dyld_up)
     m_dyld_up.reset(DynamicLoader::FindPlugin(this, nullptr));
   return m_dyld_up.get();
 }
 
-const lldb::DataBufferSP Process::GetAuxvData() { return DataBufferSP(); }
+DataExtractor Process::GetAuxvData() { return DataExtractor(); }
 
 JITLoaderList &Process::GetJITLoaders() {
   if (!m_jit_loaders_up) {
     m_jit_loaders_up.reset(new JITLoaderList());
     JITLoader::LoadPlugins(this, *m_jit_loaders_up);
   }
   return *m_jit_loaders_up;
 }