Remove Platform usages from NativeProcessLinux

[labath]

Summary

this removes the last usage of the Platform plugin in NPL. It was being used for determining the
architecture of a running process locating the ELF file belonging to the process and parsing it.
Given that we are already attached to the process we can replace this with a more reliable method
using the "official" ptrace API for that (it doesn't look very official, but this is what e.g.
strace uses).

Together with a followup change, which I am in the process of preparing, this will shrink
lldb-server by 4%--9% (mostly depending on how large the file is right now -- i.e., if it
includes instruction emulator plugins).

Tested on x86 and arm.

[labath]

@nitesh.jain: I have checked that this compiles, but I could not verify the functionality for lack of hardware. Could you give this a spin? I am particularly interested in the "debugging 32 bit process with a 64 bit server" use case as that is most likely to break. If it does, you can probably fix it by tweaking the number passed to GetThreadArchitecture -- it should be the size that the ptrace(GETREGSET, NT_PRSTATUS) returns for a 64-bit process.

@uweigand: This should not affect functionality in any way, as you don't do multiarch (afaik), but the changes to the register context were eyeballed, so I'm not sure if it actually compiles.

[uweigand]

This patch builds and works fine on s390x-linux.

[nitesh.jain]

Let me check and get back to you.

Thanks.

[tberghammer]

Looks good with 1 minor comment inline. Feel free to ignore/postpone it if you want

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2072–2073

Can we just remove this entry method as nobody is using it?

[nitesh.jain]

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

39

Ptrace call with ptrace request "PTRACE_GETREGSET" is failing for MIPS. We are currently investigating the reason for the failure. I will let you know asap.

Thanks

[labath]

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

39

Thanks for checking it out. I'll hold this for now.

Out of curiosity, what is errno being set to after this? Also, in which scenario does this happen (64->64 or 64->32, 32->32)?

[labath]

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

39

Also, what is the kernel version you are using? NT_PRSTATUS was apparently added in 3.13, although I'm not sure if all the all the necessary pieces were there already -- (it may have been enabled slightly later).

[omjavaid]

Seems to be causing no regressions on arm-linux.

[jaydeep]

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

53

We have tried executing ptrace(NT_PRSTATUS) on MIPS with 3.18. It is able to detect the arch correctly (64->64 and 64->32). However with 3.10 it fails with EIO. Is there any fallback method when ptrace(NT_PRSTATUS) fails?

[labath]

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

53

Thanks for checking that out.

This makes things a bit tricky. We *could* fallback to the "parse the executable ELF" method of getting the architecture, but that would make this patch a bit pointless, as that is what I am trying to remove in the first place. I suppose we could make the fallback mips-only, but that will not be too ideal either.

I don't know about any other fallbacks. It would be interesting to know how strace does that. I've tried looking at strace source code, but I could not make much out of it. Do you know if a single strace binary is capable of correctly tracing both 32- and 64-bit processes? If so, could you try running the following experiment for me:

• create a simple c file that does a sleep(1) and exits
• compile 32- and 64-bit versions of the executable
• execute the following commands:

strace -o /tmp/32.txt -- strace -o /dev/null -- a.out.32
strace -o /tmp/64.txt -- strace -o /dev/null -- a.out.64

Could you send me the outputs (32.txt, 64.txt). Maybe I'll be able to figure something out from that.

If that does not work, I may have to abandon this.

thanks.

[nitesh.jain]

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

53

// 32 bit ELF
gcc-4.9 -g -O0 -mabi=64 -mips64r2 simple.c -o a.out.64

// 64 bit ELF
gcc-4.9 -g -O0 -mabi=32 -mips32r2 simple.c -o a.out.32

// Strace for 32 and 64 bit
strace -o /tmp/64.txt -- strace -o /dev/null -- ./a.out.64
strace -o /tmp/32.txt -- strace -o /dev/null -- ./a.out.32

// File command output for both file

a.out.64: ELF 64-bit LSB executable, MIPS, MIPS64 rel2 version 1 (SYSV), dynamically linked, interpreter /lib64/ld.so.1, BuildID[sha1]=6e0f92a8abee292b4b6462d79ec0420a3d8aaad0, for GNU/Linux 2.6.32, not stripped

a.out.32: ELF 32-bit LSB executable, MIPS, MIPS32 rel2 version 1, dynamically linked, interpreter /lib/ld.so.1, for GNU/Linux 2.6.32, BuildID[sha1]=c4e09148526975f777e3e70bec85868616d3ce94, not stripped

32.txt37 KBDownload

64.txt51 KBDownload

[nitesh.jain]

In case of MIPS, ptrace always return 64 bit data irrespetive of Arch.

[labath]

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

53

Thank you for helping me investigate this. I've been thinking about it a lot, and I don't see any other way to get around this limitation at the moment. I think we'll have to abandon this approach for now.

[labath]

Use an auxv-based approach for detecting the architecture in case of mips.

[labath]

@nitesh.jain could you give the new version one more spin. I tried it on the auxv files you sent me, and it should work, but maybe there are other issues we did not notice. And thank you again for the help and all the patience.

Everyone else: The new version has only mips-specific changes, so I don't think there any action for you here.

[nitesh.jain]

I will check it and let you know asap.

Thanks

[nitesh.jain]

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

430

There are three flavours of ABI,

ABI	pointer-size	Arch	Processs Type
O32	4	Mips32	32 bit
N32	4	Mips64	32 bit
N64	8	Mips64	64 bit

So not sure whether it will work for "N32", I will check and let you know asap.

[labath]

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

430

Uh-oh. :)

So, I don't think the ABI should matter much to the native register context. What matters here is the registers and their sizes. I'm guessing the N32 thing is something like the x32 intel abi, wher all registers are 64-bit, but sizeof(void*) is 32-bit. In that case this function will not work correctly, as it will detect it as 32-bit (but the NT_PRSTATUS-based one would, I guess).

Does N32 work on pre-3.13 kernels? (Grepping the source seems to find mentions of it, but i don't know how well it actually worked).

I guess is back to drawing board with this one again. Could you please send me the contents of the N32 auxiliary vector (LD_SHOW_AUXV as well as the actual binary contents). I presume the one you sent me earlier was O32.

cheers,
pl

[nitesh.jain]

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

430

In N32 ABI, all GPR register are 64 bit and sizeof(void *) is 32 bit.

Yes, N32 ABI works on pre-3.13 kernels. I have send earlier aux for O32 ABI .

Thanks,
Nj

[labath]

I am abandoning this in favor of D21324, which achieves the same result (no Platform plugin), but still uses the elf-parsing method to keep everything working as is now.

You can give it a try if you want, but I don't anticipate any architecture-specific problems as all the changes are in generic code. Thanks for the patience.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

2072–2073

The function is pure virtual in the base class, so I cannot just remove it.

source/Plugins/Process/Linux/NativeProcessLinux.h

private:
         std::map<lldb::tid_t, lldb::addr_t> m_threads_stepping_with_breakpoint;
 
         /// @class LauchArgs
         ///
         /// @brief Simple structure to pass data to the thread responsible for
         /// launching a child process.
         struct LaunchArgs
         {
-            LaunchArgs(Module *module,
-                    char const **argv,
-                    char const **envp,
-                    const FileSpec &stdin_file_spec,
-                    const FileSpec &stdout_file_spec,
-                    const FileSpec &stderr_file_spec,
-                    const FileSpec &working_dir,
+            LaunchArgs(char const **argv, char const **envp, const FileSpec &stdin_file_spec,
+                       const FileSpec &stdout_file_spec, const FileSpec &stderr_file_spec, const FileSpec &working_dir,
                        const ProcessLaunchInfo &launch_info);
 
             ~LaunchArgs();
 
-            Module *m_module;                  // The executable image to launch.
             char const **m_argv;               // Process arguments.
             char const **m_envp;               // Process environment.
             const FileSpec m_stdin_file_spec;  // Redirect stdin if not empty.
             const FileSpec m_stdout_file_spec; // Redirect stdout if not empty.
             const FileSpec m_stderr_file_spec; // Redirect stderr if not empty.
             const FileSpec m_working_dir;      // Working directory or empty.
             const ProcessLaunchInfo &m_launch_info;
         };
 
         typedef std::function< ::pid_t(Error &)> InitialOperation;
 
         // ---------------------------------------------------------------------
         // Private Instance Methods
         // ---------------------------------------------------------------------
         NativeProcessLinux ();
 
         /// Launches an inferior process ready for debugging.  Forms the
         /// implementation of Process::DoLaunch.
         void
         LaunchInferior (
             MainLoop &mainloop,
-            Module *module,
             char const *argv[],
             char const *envp[],
             const FileSpec &stdin_file_spec,
             const FileSpec &stdout_file_spec,
             const FileSpec &stderr_file_spec,
             const FileSpec &working_dir,
             const ProcessLaunchInfo &launch_info,
             Error &error);

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 #include <mutex>
 #include <sstream>
 #include <string>
 #include <unordered_map>
 
 // Other libraries and framework includes
 #include "lldb/Core/EmulateInstruction.h"
 #include "lldb/Core/Error.h"
-#include "lldb/Core/Module.h"
-#include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/State.h"
+#include "lldb/Core/StreamString.h"
+#include "lldb/Host/Host.h"
 #include "lldb/Host/common/NativeBreakpoint.h"
 #include "lldb/Host/common/NativeRegisterContext.h"
-#include "lldb/Host/Host.h"
-#include "lldb/Host/ThreadLauncher.h"
-#include "lldb/Target/Platform.h"
-#include "lldb/Target/Process.h"
 #include "lldb/Target/ProcessLaunchInfo.h"
-#include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/PseudoTerminal.h"
 #include "lldb/Utility/StringExtractor.h"
 
-#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
+#include "NativeRegisterContextLinux.h"
 #include "NativeThreadLinux.h"
+#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "ProcFileReader.h"
 #include "Procfs.h"
 
 // System includes - They have to be included after framework includes because they define some
 // macros which collide with variable names in other modules
 #include <linux/unistd.h>
 #include <sys/socket.h>
 
std::call_once(flag, [] {
         }
     });
 
     return is_supported;
 }
 
 namespace
 {
-    Error
-    ResolveProcessArchitecture (lldb::pid_t pid, Platform &platform, ArchSpec &arch)
-    {
-        // Grab process info for the running process.
-        ProcessInstanceInfo process_info;
-        if (!platform.GetProcessInfo (pid, process_info))
-            return Error("failed to get process info");
-
-        // Resolve the executable module.
-        ModuleSP exe_module_sp;
-        ModuleSpec exe_module_spec(process_info.GetExecutableFile(), process_info.GetArchitecture());
-        FileSpecList executable_search_paths (Target::GetDefaultExecutableSearchPaths ());
-        Error error = platform.ResolveExecutable(
-            exe_module_spec,
-            exe_module_sp,
-            executable_search_paths.GetSize () ? &executable_search_paths : NULL);
-
-        if (!error.Success ())
-            return error;
-
-        // Check if we've got our architecture from the exe_module.
-        arch = exe_module_sp->GetArchitecture ();
-        if (arch.IsValid ())
-            return Error();
-        else
-            return Error("failed to retrieve a valid architecture from the exe module");
-    }
-
     void
     DisplayBytes (StreamString &s, void *bytes, uint32_t count)
     {
         uint8_t *ptr = (uint8_t *)bytes;
         const uint32_t loop_count = std::min<uint32_t>(DEBUG_PTRACE_MAXBYTES, count);
         for(uint32_t i=0; i<loop_count; i++)
         {
             s.Printf ("[%x]", *ptr);
EnsureFDFlags(int fd, int flags)
     {
         error.SetErrorToErrno();
         return error;
     }
 
     return error;
 }
 
-NativeProcessLinux::LaunchArgs::LaunchArgs(Module *module,
-                                       char const **argv,
-                                       char const **envp,
-                                       const FileSpec &stdin_file_spec,
-                                       const FileSpec &stdout_file_spec,
-                                       const FileSpec &stderr_file_spec,
-                                       const FileSpec &working_dir,
-                                       const ProcessLaunchInfo &launch_info)
-    : m_module(module),
-      m_argv(argv),
+NativeProcessLinux::LaunchArgs::LaunchArgs(char const **argv, char const **envp, const FileSpec &stdin_file_spec,
+                                           const FileSpec &stdout_file_spec, const FileSpec &stderr_file_spec,
+                                           const FileSpec &working_dir, const ProcessLaunchInfo &launch_info)
+    : m_argv(argv),
       m_envp(envp),
       m_stdin_file_spec(stdin_file_spec),
       m_stdout_file_spec(stdout_file_spec),
       m_stderr_file_spec(stderr_file_spec),
       m_working_dir(working_dir),
       m_launch_info(launch_info)
 {
 }
 
 NativeProcessLinux::LaunchArgs::~LaunchArgs()
 { }
 
 // -----------------------------------------------------------------------------
 // Public Static Methods
 // -----------------------------------------------------------------------------
 
 Error
 NativeProcessProtocol::Launch (
     ProcessLaunchInfo &launch_info,
     NativeProcessProtocol::NativeDelegate &native_delegate,
     MainLoop &mainloop,
     NativeProcessProtocolSP &native_process_sp)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
-
-    lldb::ModuleSP exe_module_sp;
-    PlatformSP platform_sp (Platform::GetHostPlatform ());
-    Error error = platform_sp->ResolveExecutable(
-            ModuleSpec(launch_info.GetExecutableFile(), launch_info.GetArchitecture()),
-            exe_module_sp,
-            nullptr);
-
-    if (! error.Success())
-        return error;
+    Error error;
 
     // Verify the working directory is valid if one was specified.
     FileSpec working_dir{launch_info.GetWorkingDirectory()};
     if (working_dir &&
             (!working_dir.ResolvePath() ||
              working_dir.GetFileType() != FileSpec::eFileTypeDirectory))
     {
         error.SetErrorStringWithFormat ("No such file or directory: %s",
NativeProcessProtocol::Launch (
     {
         native_process_sp.reset ();
         error.SetErrorStringWithFormat ("failed to register the native delegate");
         return error;
     }
 
     std::static_pointer_cast<NativeProcessLinux> (native_process_sp)->LaunchInferior (
             mainloop,
-            exe_module_sp.get(),
             launch_info.GetArguments ().GetConstArgumentVector (),
             launch_info.GetEnvironmentEntries ().GetConstArgumentVector (),
             stdin_file_spec,
             stdout_file_spec,
             stderr_file_spec,
             working_dir,
             launch_info,
             error);
NativeProcessProtocol::Attach (
     NativeProcessProtocol::NativeDelegate &native_delegate,
     MainLoop &mainloop,
     NativeProcessProtocolSP &native_process_sp)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log && log->GetMask ().Test (POSIX_LOG_VERBOSE))
         log->Printf ("NativeProcessLinux::%s(pid = %" PRIi64 ")", __FUNCTION__, pid);
 
-    // Grab the current platform architecture.  This should be Linux,
-    // since this code is only intended to run on a Linux host.
-    PlatformSP platform_sp (Platform::GetHostPlatform ());
-    if (!platform_sp)
-        return Error("failed to get a valid default platform");
-
-    // Retrieve the architecture for the running process.
-    ArchSpec process_arch;
-    Error error = ResolveProcessArchitecture (pid, *platform_sp.get (), process_arch);
-    if (!error.Success ())
-        return error;
-
     std::shared_ptr<NativeProcessLinux> native_process_linux_sp (new NativeProcessLinux ());
 
     if (!native_process_linux_sp->RegisterNativeDelegate (native_delegate))
-    {
-        error.SetErrorStringWithFormat ("failed to register the native delegate");
-        return error;
-    }
+        return Error("Failed to register the native delegate");
 
+    Error error;
     native_process_linux_sp->AttachToInferior (mainloop, pid, error);
     if (!error.Success ())
         return error;
 
     native_process_sp = native_process_linux_sp;
     return error;
 }
 
 // -----------------------------------------------------------------------------
 // Public Instance Methods
 // -----------------------------------------------------------------------------
 
 NativeProcessLinux::NativeProcessLinux () :
     NativeProcessProtocol (LLDB_INVALID_PROCESS_ID),
     m_arch (),
     m_supports_mem_region (eLazyBoolCalculate),
     m_mem_region_cache (),
     m_pending_notification_tid(LLDB_INVALID_THREAD_ID)
 {
 }
 
 void
 NativeProcessLinux::LaunchInferior (
     MainLoop &mainloop,
-    Module *module,
     const char *argv[],
     const char *envp[],
     const FileSpec &stdin_file_spec,
     const FileSpec &stdout_file_spec,
     const FileSpec &stderr_file_spec,
     const FileSpec &working_dir,
     const ProcessLaunchInfo &launch_info,
     Error &error)
 {
     m_sigchld_handle = mainloop.RegisterSignal(SIGCHLD,
             [this] (MainLoopBase &) { SigchldHandler(); }, error);
     if (! m_sigchld_handle)
         return;
 
-    if (module)
-        m_arch = module->GetArchitecture ();
-
     SetState (eStateLaunching);
 
     std::unique_ptr<LaunchArgs> args(
-        new LaunchArgs(module, argv, envp,
-                       stdin_file_spec,
-                       stdout_file_spec,
-                       stderr_file_spec,
-                       working_dir,
-                       launch_info));
+        new LaunchArgs(argv, envp, stdin_file_spec, stdout_file_spec, stderr_file_spec, working_dir, launch_info));
 
     Launch(args.get(), error);
 }
 
 void
 NativeProcessLinux::AttachToInferior (MainLoop &mainloop, lldb::pid_t pid, Error &error)
 {
     Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
     if (log)
         log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 ")", __FUNCTION__, pid);
 
     m_sigchld_handle = mainloop.RegisterSignal(SIGCHLD,
             [this] (MainLoopBase &) { SigchldHandler(); }, error);
     if (! m_sigchld_handle)
         return;
 
-    // We can use the Host for everything except the ResolveExecutable portion.
-    PlatformSP platform_sp = Platform::GetHostPlatform ();
-    if (!platform_sp)
-    {
-        if (log)
-            log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 "): no default platform set", __FUNCTION__, pid);
-        error.SetErrorString ("no default platform available");
-        return;
-    }
-
-    // Gather info about the process.
-    ProcessInstanceInfo process_info;
-    if (!platform_sp->GetProcessInfo (pid, process_info))
-    {
-        if (log)
-            log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 "): failed to get process info", __FUNCTION__, pid);
-        error.SetErrorString ("failed to get process info");
-        return;
-    }
-
-    // Resolve the executable module
-    ModuleSP exe_module_sp;
-    FileSpecList executable_search_paths (Target::GetDefaultExecutableSearchPaths());
-    ModuleSpec exe_module_spec(process_info.GetExecutableFile(), process_info.GetArchitecture());
-    error = platform_sp->ResolveExecutable(exe_module_spec, exe_module_sp,
-                                           executable_search_paths.GetSize() ? &executable_search_paths : NULL);
-    if (!error.Success())
-        return;
-
-    // Set the architecture to the exe architecture.
-    m_arch = exe_module_sp->GetArchitecture();
-    if (log)
-        log->Printf ("NativeProcessLinux::%s (pid = %" PRIi64 ") detected architecture %s", __FUNCTION__, pid, m_arch.GetArchitectureName ());
 
     m_pid = pid;
     SetState(eStateAttaching);
 
     Attach(pid, error);
+    m_arch = static_pointer_cast<NativeRegisterContextLinux>(GetThreadByID(pid)->GetRegisterContext())
+                 ->GetRegisterInfoInterface()
+                 .GetTargetArchitecture();
+
+    if (log)
+        log->Printf("NativeProcessLinux::%s (pid = %" PRIi64 ") detected architecture %s", __FUNCTION__, pid,
+                    m_arch.GetArchitectureName());
 }
 
 ::pid_t
 NativeProcessLinux::Launch(LaunchArgs *args, Error &error)
 {
     assert (args && "null args");
 
     const char **argv = args->m_argv;
NativeProcessLinux::Launch(LaunchArgs *args, Error &error)
     if (log)
         log->Printf ("NativeProcessLinux::%s() adding pid = %" PRIu64, __FUNCTION__, pid);
 
     NativeThreadLinuxSP thread_sp = AddThread(pid);
     assert (thread_sp && "AddThread() returned a nullptr thread");
     thread_sp->SetStoppedBySignal(SIGSTOP);
     ThreadWasCreated(*thread_sp);
 
+    m_arch = static_pointer_cast<NativeRegisterContextLinux>(thread_sp->GetRegisterContext())
+                 ->GetRegisterInfoInterface()
+                 .GetTargetArchitecture();
+
     // Let our process instance know the thread has stopped.
     SetCurrentThreadID (thread_sp->GetID ());
     SetState (StateType::eStateStopped);
 
     if (log)
     {
         if (error.Success ())
         {

 Error
 NativeProcessLinux::DeallocateMemory (lldb::addr_t addr)
 {
     // FIXME see comments in AllocateMemory - required lower-level
     // bits not in place yet (ThreadPlans)
     return Error ("not implemented");
 }
 
 lldb::addr_t
 NativeProcessLinux::GetSharedLibraryInfoAddress ()
 {
-#if 1
     // punt on this for now
     return LLDB_INVALID_ADDRESS;
-#else
-    // Return the image info address for the exe module
-#if 1
-    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS));
-
-    ModuleSP module_sp;
-    Error error = GetExeModuleSP (module_sp);
-    if (error.Fail ())
-    {
-         if (log)
-            log->Warning ("NativeProcessLinux::%s failed to retrieve exe module: %s", __FUNCTION__, error.AsCString ());
-        return LLDB_INVALID_ADDRESS;
-    }
-
-    if (module_sp == nullptr)
-    {
-         if (log)
-            log->Warning ("NativeProcessLinux::%s exe module returned was NULL", __FUNCTION__);
-         return LLDB_INVALID_ADDRESS;
-    }
-
-    ObjectFileSP object_file_sp = module_sp->GetObjectFile ();
-    if (object_file_sp == nullptr)
-    {
-         if (log)
-            log->Warning ("NativeProcessLinux::%s exe module returned a NULL object file", __FUNCTION__);
-         return LLDB_INVALID_ADDRESS;
-    }
-
-    return obj_file_sp->GetImageInfoAddress();
-#else
-    Target *target = &GetTarget();
-    ObjectFile *obj_file = target->GetExecutableModule()->GetObjectFile();
-    Address addr = obj_file->GetImageInfoAddress(target);
-
-    if (addr.IsValid())
-        return addr.GetLoadAddress(target);
-    return LLDB_INVALID_ADDRESS;
-#endif
-#endif // punt on this for now
 }
 
 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

source/Plugins/Process/Linux/NativeRegisterContextLinux.h

 //===-- NativeRegisterContextLinux.h ----------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef lldb_NativeRegisterContextLinux_h
 #define lldb_NativeRegisterContextLinux_h
 
+#include "lldb/Host/HostInfo.h"
 #include "lldb/Host/common/NativeRegisterContextRegisterInfo.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 
 #include "Plugins/Process/Linux/NativeProcessLinux.h"
 
 namespace lldb_private {
 namespace process_linux {
 
 class NativeRegisterContextLinux : public NativeRegisterContextRegisterInfo
 {
 public:
     NativeRegisterContextLinux(NativeThreadProtocol &native_thread,
                                uint32_t concrete_frame_idx,
                                RegisterInfoInterface *reg_info_interface_p);
 
     // This function is implemented in the NativeRegisterContextLinux_* subclasses to create a new
     // instance of the host specific NativeRegisterContextLinux. The implementations can't collide
     // as only one NativeRegisterContextLinux_* variant should be compiled into the final
     // executable.
-    static NativeRegisterContextLinux*
-    CreateHostNativeRegisterContextLinux(const ArchSpec& target_arch,
-                                         NativeThreadProtocol &native_thread,
-                                         uint32_t concrete_frame_idx);
+    static NativeRegisterContextLinux *
+    CreateHostNativeRegisterContextLinux(NativeThreadProtocol &native_thread, uint32_t concrete_frame_idx);
 
 protected:
+    static ArchSpec
+    GetThreadArchitecture(lldb::tid_t tid, size_t sizeof_native_regs_struct);
+
     lldb::ByteOrder
     GetByteOrder() const;
 
     virtual Error
     ReadRegisterRaw(uint32_t reg_index, RegisterValue& reg_value);
 
     virtual Error
     WriteRegisterRaw(uint32_t reg_index, const RegisterValue& reg_value);

source/Plugins/Process/Linux/NativeRegisterContextLinux.cpp

 //===-- NativeRegisterContextLinux.cpp --------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "NativeRegisterContextLinux.h"
 
+#include <elf.h>
+
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Host/common/NativeProcessProtocol.h"
 #include "lldb/Host/common/NativeThreadProtocol.h"
 #include "lldb/Host/linux/Ptrace.h"
+#include "lldb/Host/linux/Uio.h"
 
 #include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
+ArchSpec
+NativeRegisterContextLinux::GetThreadArchitecture(lldb::tid_t tid, size_t sizeof_native_regs_struct)
+{
+    // This relies on the fact that the size of the set that PTRACE_GETREGSET will return depends
+    // on the bitness of the target process. If the target process has the same bitness as us, we
+    // will get the expected number of bytes. If it returns less, we it means we are debugging a
+    // 32-bit process with a 64-bit server (the opposite is not possible).
+    Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_REGISTERS));
+
+    std::unique_ptr<char[]> regs(new char[sizeof_native_regs_struct]);
+    struct iovec ioVec;
+    ioVec.iov_base = regs.get();
+    ioVec.iov_len = sizeof_native_regs_struct;
+    int regset = NT_PRSTATUS;
+    Error error = NativeProcessLinux::PtraceWrapper(PTRACE_GETREGSET, tid, &regset, &ioVec, sizeof_native_regs_struct);
+    HostInfo::ArchitectureKind kind = HostInfo::eArchKindDefault; // same bitness this process
+    // The ptrace call should only fail if the process has gone away (via SIGKILL). In that
+    // case, it doesn't matter which architecture it was.
+    if (error.Success() && ioVec.iov_len < sizeof_native_regs_struct)
+        kind = HostInfo::eArchKind32; //  32-bit process on a 64-bit server
+    if (log)
+        log->Printf("NativeRegisterContextLinux::%s(tid: %" PRIu64
+                    ", sizeof_native_regs_struct: %zd) iov_len = %zd => %s",
+                    __FUNCTION__, tid, sizeof_native_regs_struct, ioVec.iov_len,
+                    HostInfo::GetArchitecture(kind).GetArchitectureName());
+    return HostInfo::GetArchitecture(kind);
+}
+
 NativeRegisterContextLinux::NativeRegisterContextLinux(NativeThreadProtocol &native_thread,
                                                        uint32_t concrete_frame_idx,
                                                        RegisterInfoInterface *reg_info_interface_p) :
     NativeRegisterContextRegisterInfo(native_thread, concrete_frame_idx, reg_info_interface_p)
 {}
 
 lldb::ByteOrder
 NativeRegisterContextLinux::GetByteOrder() const
 {

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.h

 namespace lldb_private {
 namespace process_linux {
 
     class NativeProcessLinux;
 
     class NativeRegisterContextLinux_arm : public NativeRegisterContextLinux
     {
     public:
-        NativeRegisterContextLinux_arm (const ArchSpec& target_arch,
-                                        NativeThreadProtocol &native_thread,
-                                        uint32_t concrete_frame_idx);
+        NativeRegisterContextLinux_arm(NativeThreadProtocol &native_thread, uint32_t concrete_frame_idx);
 
         uint32_t
         GetRegisterSetCount () const override;
 
         const RegisterSet *
         GetRegisterSet (uint32_t set_index) const override;
 
         uint32_t

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

 #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
 
 #include "NativeRegisterContextLinux_arm.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/RegisterValue.h"
+#include "lldb/Host/HostInfo.h"
 
 #include "Plugins/Process/Linux/Procfs.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_arm.h"
 
 #include <elf.h>
 #include <sys/socket.h>
 
 #define REG_CONTEXT_SIZE (GetGPRSize() + sizeof (m_fpr))

 g_reg_sets_arm[k_num_register_sets] =
 {
     { "General Purpose Registers",  "gpr", k_num_gpr_registers_arm, g_gpr_regnums_arm },
     { "Floating Point Registers",   "fpu", k_num_fpr_registers_arm, g_fpu_regnums_arm }
 };
 
 #if defined(__arm__)
 
-NativeRegisterContextLinux*
-NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(const ArchSpec& target_arch,
-                                                                 NativeThreadProtocol &native_thread,
+NativeRegisterContextLinux *
+NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(NativeThreadProtocol &native_thread,
                                                                  uint32_t concrete_frame_idx)
 {
-    return new NativeRegisterContextLinux_arm(target_arch, native_thread, concrete_frame_idx);
+    return new NativeRegisterContextLinux_arm(native_thread, concrete_frame_idx);
 }
 
 #endif // defined(__arm__)
 
-NativeRegisterContextLinux_arm::NativeRegisterContextLinux_arm (const ArchSpec& target_arch,
-                                                                NativeThreadProtocol &native_thread,
-                                                                uint32_t concrete_frame_idx) :
-    NativeRegisterContextLinux (native_thread, concrete_frame_idx, new RegisterContextLinux_arm(target_arch))
-{
-    switch (target_arch.GetMachine())
-    {
-        case llvm::Triple::arm:
+NativeRegisterContextLinux_arm::NativeRegisterContextLinux_arm(NativeThreadProtocol &native_thread,
+                                                               uint32_t concrete_frame_idx)
+    : NativeRegisterContextLinux(native_thread, concrete_frame_idx,
+                                 new RegisterContextLinux_arm(HostInfo::GetArchitecture(HostInfo::eArchKind32)))
             m_reg_info.num_registers     = k_num_registers_arm;
             m_reg_info.num_gpr_registers = k_num_gpr_registers_arm;
             m_reg_info.num_fpr_registers = k_num_fpr_registers_arm;
             m_reg_info.last_gpr          = k_last_gpr_arm;
             m_reg_info.first_fpr         = k_first_fpr_arm;
             m_reg_info.last_fpr          = k_last_fpr_arm;
             m_reg_info.first_fpr_v       = fpu_s0_arm;
             m_reg_info.last_fpr_v        = fpu_s31_arm;
             m_reg_info.gpr_flags         = gpr_cpsr_arm;
-            break;
-        default:
-            assert(false && "Unhandled target architecture.");
-            break;
-    }
 
     ::memset(&m_fpr, 0, sizeof (m_fpr));
     ::memset(&m_gpr_arm, 0, sizeof (m_gpr_arm));
     ::memset(&m_hwp_regs, 0, sizeof (m_hwp_regs));
 
     // 16 is just a maximum value, query hardware for actual watchpoint count
     m_max_hwp_supported = 16;
     m_max_hbp_supported = 16;

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

 namespace lldb_private {
 namespace process_linux {
 
     class NativeProcessLinux;
 
     class NativeRegisterContextLinux_arm64 : public NativeRegisterContextLinux
     {
     public:
-        NativeRegisterContextLinux_arm64 (const ArchSpec& target_arch,
-                                          NativeThreadProtocol &native_thread,
-                                          uint32_t concrete_frame_idx);
+        NativeRegisterContextLinux_arm64(NativeThreadProtocol &native_thread, uint32_t concrete_frame_idx);
 
         uint32_t
         GetRegisterSetCount () const override;
 
         uint32_t
         GetUserRegisterCount() const override;
 
         const RegisterSet *

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

 // Register sets for ARM64.
 static const RegisterSet
 g_reg_sets_arm64[k_num_register_sets] =
 {
     { "General Purpose Registers",  "gpr", k_num_gpr_registers_arm64, g_gpr_regnums_arm64 },
     { "Floating Point Registers",   "fpu", k_num_fpr_registers_arm64, g_fpu_regnums_arm64 }
 };
 
-NativeRegisterContextLinux*
-NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(const ArchSpec& target_arch,
-                                                                 NativeThreadProtocol &native_thread,
+NativeRegisterContextLinux *
+NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(NativeThreadProtocol &native_thread,
                                                                  uint32_t concrete_frame_idx)
 {
     Log *log  = ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_REGISTERS);
+    ArchSpec target_arch = GetThreadArchitecture(native_thread.GetID(), sizeof(struct user_regs_struct));
+
     switch (target_arch.GetMachine())
     {
         case llvm::Triple::arm:
-            return new NativeRegisterContextLinux_arm(target_arch, native_thread, concrete_frame_idx);
+            return new NativeRegisterContextLinux_arm(native_thread, concrete_frame_idx);
         case llvm::Triple::aarch64:
-            return new NativeRegisterContextLinux_arm64(target_arch, native_thread, concrete_frame_idx);
+            return new NativeRegisterContextLinux_arm64(native_thread, concrete_frame_idx);
         default:
             if (log)
                 log->Printf("NativeRegisterContextLinux::%s() have no register context for architecture: %s\n", __FUNCTION__,
                             target_arch.GetTriple().getArchName().str().c_str());
             return nullptr;
     }
 }
 
-NativeRegisterContextLinux_arm64::NativeRegisterContextLinux_arm64 (const ArchSpec& target_arch,
-                                                                    NativeThreadProtocol &native_thread,
-                                                                    uint32_t concrete_frame_idx) :
-    NativeRegisterContextLinux (native_thread, concrete_frame_idx, new RegisterContextLinux_arm64(target_arch))
-{
-    switch (target_arch.GetMachine())
-    {
-        case llvm::Triple::aarch64:
+NativeRegisterContextLinux_arm64::NativeRegisterContextLinux_arm64(NativeThreadProtocol &native_thread,
+                                                                   uint32_t concrete_frame_idx)
+    : NativeRegisterContextLinux(native_thread, concrete_frame_idx,
+                                 new RegisterContextLinux_arm64(HostInfo::GetArchitecture(HostInfo::eArchKind64)))
             m_reg_info.num_registers     = k_num_registers_arm64;
             m_reg_info.num_gpr_registers = k_num_gpr_registers_arm64;
             m_reg_info.num_fpr_registers = k_num_fpr_registers_arm64;
             m_reg_info.last_gpr          = k_last_gpr_arm64;
             m_reg_info.first_fpr         = k_first_fpr_arm64;
             m_reg_info.last_fpr          = k_last_fpr_arm64;
             m_reg_info.first_fpr_v       = fpu_v0_arm64;
             m_reg_info.last_fpr_v        = fpu_v31_arm64;
             m_reg_info.gpr_flags         = gpr_cpsr_arm64;
-            break;
-        default:
-            assert(false && "Unhandled target architecture.");
-            break;
-    }
 
     ::memset(&m_fpr, 0, sizeof (m_fpr));
     ::memset(&m_gpr_arm64, 0, sizeof (m_gpr_arm64));
     ::memset(&m_hwp_regs, 0, sizeof (m_hwp_regs));
 
     // 16 is just a maximum value, query hardware for actual watchpoint count
     m_max_hwp_supported = 16;
     m_max_hbp_supported = 16;

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.h

 namespace lldb_private {
 namespace process_linux {
 
     class NativeProcessLinux;
 
     class NativeRegisterContextLinux_mips64 : public NativeRegisterContextLinux
     {
     public:
-        NativeRegisterContextLinux_mips64 (const ArchSpec& target_arch,
-                                           NativeThreadProtocol &native_thread, 
-                                           uint32_t concrete_frame_idx);
+        NativeRegisterContextLinux_mips64(NativeThreadProtocol &native_thread, uint32_t concrete_frame_idx);
 
         uint32_t
         GetRegisterSetCount () const override;
 
         lldb::addr_t
         GetPCfromBreakpointLocation (lldb::addr_t fail_value = LLDB_INVALID_ADDRESS) override;
 
         lldb::addr_t
private:
 
         FPR_linux_mips m_fpr;
 
         MSA_linux_mips m_msa;
 
         lldb::addr_t hw_addr_map[MAX_NUM_WP];
 
         IOVEC_mips m_iovec;
+
+        static RegisterInfoInterface *
+        CreateRegisterInfoInterface(NativeThreadProtocol &native_thread);
     };
 
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef lldb_NativeRegisterContextLinux_mips64_h
 
 #endif // defined (__mips__)

source/Plugins/Process/Linux/NativeRegisterContextLinux_mips64.cpp

namespace
     {
         { "General Purpose Registers",  "gpr", k_num_gpr_registers_mips64, g_gp_regnums_mips64 },
         { "Floating Point Registers",   "fpu", k_num_fpr_registers_mips64, g_fp_regnums_mips64 },
         { "MSA Registers",              "msa", k_num_msa_registers_mips64, g_msa_regnums_mips64 },
     };
 
 } // end of anonymous namespace
 
-NativeRegisterContextLinux*
-NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(const ArchSpec& target_arch,
-                                                                 NativeThreadProtocol &native_thread,
+NativeRegisterContextLinux *
+NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(NativeThreadProtocol &native_thread,
                                                                  uint32_t concrete_frame_idx)
 {
-    return new NativeRegisterContextLinux_mips64(target_arch, native_thread, concrete_frame_idx);
+    return new NativeRegisterContextLinux_mips64(native_thread, concrete_frame_idx);
 }
 
 #define REG_CONTEXT_SIZE (GetRegisterInfoInterface ().GetGPRSize () + sizeof(FPR_linux_mips) + sizeof(MSA_linux_mips))
 
 // ----------------------------------------------------------------------------
 // NativeRegisterContextLinux_mips64 members.
 // ----------------------------------------------------------------------------
 
-static RegisterInfoInterface*
-CreateRegisterInfoInterface(const ArchSpec& target_arch)
+RegisterInfoInterface *
+NativeRegisterContextLinux_mips64::CreateRegisterInfoInterface(NativeThreadProtocol &native_thread)
 {
+    ArchSpec target_arch = GetThreadArchitecture(native_thread.GetID(), sizeof(long) * NGREG);
+
     if (HostInfo::GetArchitecture().GetAddressByteSize() == 4)
     {
         // 32-bit hosts run with a RegisterContextLinux_mips context.
         return new RegisterContextLinux_mips(target_arch, NativeRegisterContextLinux_mips64::IsMSAAvailable());
     }
     else
     {
         assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
                "Register setting path assumes this is a 64-bit host");
         // mips64 hosts know how to work with 64-bit and 32-bit EXEs using the mips64 register context.
         return new RegisterContextLinux_mips64 (target_arch, NativeRegisterContextLinux_mips64::IsMSAAvailable());
     }
 }
 
-NativeRegisterContextLinux_mips64::NativeRegisterContextLinux_mips64 (const ArchSpec& target_arch,
-                                                                      NativeThreadProtocol &native_thread, 
-                                                                      uint32_t concrete_frame_idx) :
-    NativeRegisterContextLinux (native_thread, concrete_frame_idx, CreateRegisterInfoInterface(target_arch))
+NativeRegisterContextLinux_mips64::NativeRegisterContextLinux_mips64(NativeThreadProtocol &native_thread,
+                                                                     uint32_t concrete_frame_idx)
+    : NativeRegisterContextLinux(native_thread, concrete_frame_idx, CreateRegisterInfoInterface(native_thread))
 {
-    switch (target_arch.GetMachine ())
+    switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine())
     {
         case llvm::Triple::mips:
         case llvm::Triple::mipsel:
             m_reg_info.num_registers        = k_num_registers_mips;
             m_reg_info.num_gpr_registers    = k_num_gpr_registers_mips;
             m_reg_info.num_fpr_registers    = k_num_fpr_registers_mips;
             m_reg_info.last_gpr             = k_last_gpr_mips;
             m_reg_info.first_fpr            = k_first_fpr_mips;

source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.h

 namespace process_linux
 {
 
 class NativeProcessLinux;
 
 class NativeRegisterContextLinux_s390x : public NativeRegisterContextLinux
 {
 public:
-    NativeRegisterContextLinux_s390x(const ArchSpec &target_arch, NativeThreadProtocol &native_thread,
-                                     uint32_t concrete_frame_idx);
+    NativeRegisterContextLinux_s390x(NativeThreadProtocol &native_thread, uint32_t concrete_frame_idx);
 
     uint32_t
     GetRegisterSetCount() const override;
 
     const RegisterSet *
     GetRegisterSet(uint32_t set_index) const override;
 
     uint32_t

source/Plugins/Process/Linux/NativeRegisterContextLinux_s390x.cpp

 // ----------------------------------------------------------------------------
 // Required ptrace defines.
 // ----------------------------------------------------------------------------
 
 #define NT_S390_LAST_BREAK  0x306 /* s390 breaking event address */
 #define NT_S390_SYSTEM_CALL 0x307 /* s390 system call restart data */
 
 NativeRegisterContextLinux *
-NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(const ArchSpec &target_arch,
-                                                                 NativeThreadProtocol &native_thread,
+NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(NativeThreadProtocol &native_thread,
                                                                  uint32_t concrete_frame_idx)
 {
-    return new NativeRegisterContextLinux_s390x(target_arch, native_thread, concrete_frame_idx);
+    return new NativeRegisterContextLinux_s390x(native_thread, concrete_frame_idx);
 }
 
 // ----------------------------------------------------------------------------
 // NativeRegisterContextLinux_s390x members.
 // ----------------------------------------------------------------------------
 
-static RegisterInfoInterface *
-CreateRegisterInfoInterface(const ArchSpec &target_arch)
-{
-    assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
-           "Register setting path assumes this is a 64-bit host");
-    return new RegisterContextLinux_s390x(target_arch);
-}
-
-NativeRegisterContextLinux_s390x::NativeRegisterContextLinux_s390x(const ArchSpec &target_arch,
-                                                                   NativeThreadProtocol &native_thread,
+NativeRegisterContextLinux_s390x::NativeRegisterContextLinux_s390x(NativeThreadProtocol &native_thread,
                                                                    uint32_t concrete_frame_idx)
-    : NativeRegisterContextLinux(native_thread, concrete_frame_idx, CreateRegisterInfoInterface(target_arch))
+    : NativeRegisterContextLinux(native_thread, concrete_frame_idx,
+                                 new RegisterContextLinux_s390x(HostInfo::GetArchitecture(HostInfo::eArchKindDefault)))
 {
-    // Set up data about ranges of valid registers.
-    switch (target_arch.GetMachine())
-    {
-        case llvm::Triple::systemz:
             m_reg_info.num_registers = k_num_registers_s390x;
             m_reg_info.num_gpr_registers = k_num_gpr_registers_s390x;
             m_reg_info.num_fpr_registers = k_num_fpr_registers_s390x;
             m_reg_info.last_gpr = k_last_gpr_s390x;
             m_reg_info.first_fpr = k_first_fpr_s390x;
             m_reg_info.last_fpr = k_last_fpr_s390x;
-            break;
-        default:
-            assert(false && "Unhandled target architecture.");
-            break;
-    }
 
     // Clear out the watchpoint state.
     m_watchpoint_addr = LLDB_INVALID_ADDRESS;
 }
 
 uint32_t
 NativeRegisterContextLinux_s390x::GetRegisterSetCount() const
 {

source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.h

 namespace lldb_private {
 namespace process_linux {
 
     class NativeProcessLinux;
 
     class NativeRegisterContextLinux_x86_64 : public NativeRegisterContextLinux
     {
     public:
-        NativeRegisterContextLinux_x86_64 (const ArchSpec& target_arch,
-                                           NativeThreadProtocol &native_thread,
-                                           uint32_t concrete_frame_idx);
+        NativeRegisterContextLinux_x86_64(NativeThreadProtocol &native_thread, uint32_t concrete_frame_idx);
 
         uint32_t
         GetRegisterSetCount () const override;
 
         const RegisterSet *
         GetRegisterSet (uint32_t set_index) const override;
 
         uint32_t
private:
         mutable FPRType m_fpr_type;
         FPR m_fpr;
         IOVEC m_iovec;
         YMM m_ymm_set;
         RegInfo m_reg_info;
         uint64_t m_gpr_x86_64[k_num_gpr_registers_x86_64];
         uint32_t m_fctrl_offset_in_userarea;
 
+        static RegisterInfoInterface *
+        CreateRegisterInfoInterface(NativeThreadProtocol &native_thread);
+
         // Private member methods.
         bool IsRegisterSetAvailable (uint32_t set_index) const;
 
         bool
         IsGPR(uint32_t reg_index) const;
 
         FPRType
         GetFPRType () const;

source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

 //===-- NativeRegisterContextLinux_x86_64.cpp ---------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #if defined(__i386__) || defined(__x86_64__)
 
 #include "NativeRegisterContextLinux_x86_64.h"
 
+#include <sys/user.h>
+
 #include "lldb/Core/Log.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/RegisterValue.h"
-#include "lldb/Host/HostInfo.h"
 
 #include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
 #include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
 
 using namespace lldb_private;
 using namespace lldb_private::process_linux;
 
 // ----------------------------------------------------------------------------

 // Support ptrace extensions even when compiled without required kernel support
 #ifndef NT_X86_XSTATE
 #define NT_X86_XSTATE 0x202
 #endif
 #ifndef NT_PRXFPREG
 #define NT_PRXFPREG 0x46e62b7f
 #endif
 
-NativeRegisterContextLinux*
-NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(const ArchSpec& target_arch,
-                                                                 NativeThreadProtocol &native_thread,
+NativeRegisterContextLinux *
+NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(NativeThreadProtocol &native_thread,
                                                                  uint32_t concrete_frame_idx)
 {
-    return new NativeRegisterContextLinux_x86_64(target_arch, native_thread, concrete_frame_idx);
+    return new NativeRegisterContextLinux_x86_64(native_thread, concrete_frame_idx);
 }
 
 // ----------------------------------------------------------------------------
 // NativeRegisterContextLinux_x86_64 members.
 // ----------------------------------------------------------------------------
 
-static RegisterInfoInterface*
-CreateRegisterInfoInterface(const ArchSpec& target_arch)
+RegisterInfoInterface *
+NativeRegisterContextLinux_x86_64::CreateRegisterInfoInterface(NativeThreadProtocol &native_thread)
 {
+    ArchSpec target_arch = GetThreadArchitecture(native_thread.GetID(), sizeof(struct user_regs_struct));
+
     if (HostInfo::GetArchitecture().GetAddressByteSize() == 4)
     {
         // 32-bit hosts run with a RegisterContextLinux_i386 context.
         return new RegisterContextLinux_i386(target_arch);
     }
     else
     {
         assert((HostInfo::GetArchitecture().GetAddressByteSize() == 8) &&
                "Register setting path assumes this is a 64-bit host");
         // X86_64 hosts know how to work with 64-bit and 32-bit EXEs using the x86_64 register context.
         return new RegisterContextLinux_x86_64 (target_arch);
     }
 }
 
-NativeRegisterContextLinux_x86_64::NativeRegisterContextLinux_x86_64 (const ArchSpec& target_arch,
-                                                                      NativeThreadProtocol &native_thread,
-                                                                      uint32_t concrete_frame_idx) :
-    NativeRegisterContextLinux (native_thread, concrete_frame_idx, CreateRegisterInfoInterface(target_arch)),
-    m_fpr_type (eFPRTypeNotValid),
-    m_fpr (),
-    m_iovec (),
-    m_ymm_set (),
-    m_reg_info (),
-    m_gpr_x86_64 ()
+NativeRegisterContextLinux_x86_64::NativeRegisterContextLinux_x86_64(NativeThreadProtocol &native_thread,
+                                                                     uint32_t concrete_frame_idx)
+    : NativeRegisterContextLinux(native_thread, concrete_frame_idx, CreateRegisterInfoInterface(native_thread)),
+      m_fpr_type(eFPRTypeNotValid),
+      m_fpr(),
+      m_iovec(),
+      m_ymm_set(),
+      m_reg_info(),
+      m_gpr_x86_64()
 {
     // Set up data about ranges of valid registers.
-    switch (target_arch.GetMachine ())
+    switch (GetRegisterInfoInterface().GetTargetArchitecture().GetMachine())
     {
         case llvm::Triple::x86:
             m_reg_info.num_registers        = k_num_registers_i386;
             m_reg_info.num_gpr_registers    = k_num_gpr_registers_i386;
             m_reg_info.num_fpr_registers    = k_num_fpr_registers_i386;
             m_reg_info.num_avx_registers    = k_num_avx_registers_i386;
             m_reg_info.last_gpr             = k_last_gpr_i386;
             m_reg_info.first_fpr            = k_first_fpr_i386;

source/Plugins/Process/Linux/NativeThreadLinux.cpp

NativeThreadLinux::GetRegisterContext ()
     // Return the register context if we already created it.
     if (m_reg_context_sp)
         return m_reg_context_sp;
 
     NativeProcessProtocolSP m_process_sp = m_process_wp.lock ();
     if (!m_process_sp)
         return NativeRegisterContextSP ();
 
-    ArchSpec target_arch;
-    if (!m_process_sp->GetArchitecture (target_arch))
-        return NativeRegisterContextSP ();
-
     const uint32_t concrete_frame_idx = 0;
-    m_reg_context_sp.reset (NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(target_arch,
-                                                                                             *this,
-                                                                                             concrete_frame_idx));
+    m_reg_context_sp.reset(NativeRegisterContextLinux::CreateHostNativeRegisterContextLinux(*this, concrete_frame_idx));
 
     return m_reg_context_sp;
 }
 
 Error
 NativeThreadLinux::SetWatchpoint (lldb::addr_t addr, size_t size, uint32_t watch_flags, bool hardware)
 {
     if (!hardware)