PTRACE ABI to read FXSAVE area for 32-bit inferior

[abhishek.aggarwal]

Summary

• Problem occurs when:
  • 32-bit inferiors run on x86_32 machine and the architecture doesn't have AVX feature
  • This causes FPRType to be set to eFPRTypeFXSAVE
  • PTRACE_GETFPREGS was being used to read FXSAVE area
  • For 32-bit inferiors running on x86_32 machine, PTRACE_GETFPREGS reads FSAVE area and not FXSAVE area
• Changed ptrace API to PTRACE_GETREGSET for 32-bit inferiors
  • This reads FPR data in FXSAVE format.
  • For 64-bit inferiors, no change has been made.
• Modified XFAIL for TestReturnValue.py
  • Earlier, this test was passing for Linux OS
  • Now, it passes for Android OS as well

Change-Id: Ieed72bc969b79516fc7b263b32493aa1e7a1a2ac
Signed-off-by: Abhishek Aggarwal <[e-mail]>

[tberghammer]

source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

849–850

I think we don't want this assert because of 2 reason:

• If we are running on a machine where we can't access to any floating point registers then this assert will fire but lldb is still functional in that case
• It is changing the internal state of the object so it will cause a different behavior in debug and in release builds what we should avoid as it can cause hard to diagnose issues

[abhishek.aggarwal]

Removed assert if ptrace API fails

[clayborg]

I can't intelligently comment on low level ptrace stuff, so I will defer to others that can.

[abhishek.aggarwal]

Hello Greg

Is there anyone else , except the reviewers already included for the patch, I should put as the reviewer for this patch ?

[labath]

Looks good.

[tberghammer]

Looks good, and as it only effects Linux you can commit it just based on the review from Pavel

[abhishek.aggarwal]

Added Loggings

An indication through logs in case ptrace API fails
to read FXSAVE/XSAVE area.

[abhishek.aggarwal]

Hi Pavel and Tamas

I enabled logs in case ptrace API fails to read FXSAVE/XSAVE area. This will serve as an indicator to find the reason of failure if register read fails.

[tberghammer]

source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

853–854

Adding a log message is a good idea but please include the error message from ReadFPR in the log message. It will usually contain the error message returned by the ptrace call.

[abhishek.aggarwal]

Comments Inlined.

source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

853–854

Error message from ReadFPR along with the error number (in case ptrace API fails) are displayed during call of NativeProcessLinux::PtraceWrapper(). Hence, to avoid multiplicity, I didn't include it here. The Log message I included is an additional information regarding ptrace API failure.

packages/Python/lldbsuite/test/functionalities/return-value/TestReturnValue.py

 import lldb
 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.lldbtest import *
 
 class ReturnValueTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailurei386
+    @expectedFailureAll(oslist=["macosx","freebsd"], archs=["i386"])
     @expectedFailureWindows("llvm.org/pr24778")
     @add_test_categories(['pyapi'])
     def test_with_python(self):
         """Test getting return values from stepping out."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         error = lldb.SBError()
 

source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.cpp

 // ----------------------------------------------------------------------------
 // Required ptrace defines.
 // ----------------------------------------------------------------------------
 
 // 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,
                                                                  uint32_t concrete_frame_idx)
 {
     return new NativeRegisterContextLinux_x86_64(target_arch, native_thread, concrete_frame_idx);
 }

 {
     // GPRs come first.
     return reg_index <= m_reg_info.last_gpr;
 }
 
 NativeRegisterContextLinux_x86_64::FPRType
 NativeRegisterContextLinux_x86_64::GetFPRType () const
 {
+    Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
     if (m_fpr_type == eFPRTypeNotValid)
     {
         // TODO: Use assembly to call cpuid on the inferior and query ebx or ecx.
 
         // Try and see if AVX register retrieval works.
         m_fpr_type = eFPRTypeXSAVE;
         if (const_cast<NativeRegisterContextLinux_x86_64*>(this)->ReadFPR().Fail())
         {
             // Fall back to general floating point with no AVX support.
             m_fpr_type = eFPRTypeFXSAVE;
+
+            // Check if FXSAVE area can be read.
+            if (const_cast<NativeRegisterContextLinux_x86_64*>(this)->ReadFPR().Fail())
+            {
+                if (log)
+                    log->Printf("NativeRegisterContextLinux_x86_64::%s ptrace APIs failed to read XSAVE/FXSAVE area", __FUNCTION__);
+            }
         }
     }
-
     return m_fpr_type;
 }
 
 bool
 NativeRegisterContextLinux_x86_64::IsFPR(uint32_t reg_index) const
 {
     return (m_reg_info.first_fpr <= reg_index && reg_index <= m_reg_info.last_fpr);
 }
 
 bool
 NativeRegisterContextLinux_x86_64::IsFPR(uint32_t reg_index, FPRType fpr_type) const
 {
     bool generic_fpr = IsFPR(reg_index);
 
     if (fpr_type == eFPRTypeXSAVE)
         return generic_fpr || IsAVX(reg_index);
     return generic_fpr;
 }
 
 Error
 NativeRegisterContextLinux_x86_64::WriteFPR()
 {
     const FPRType fpr_type = GetFPRType ();
+    const lldb_private::ArchSpec& target_arch = GetRegisterInfoInterface().GetTargetArchitecture();
     switch (fpr_type)
     {
     case FPRType::eFPRTypeFXSAVE:
+        // For 32-bit inferiors on x86_32/x86_64 architectures,
+        // FXSAVE area can be written using PTRACE_SETREGSET ptrace api
+        // For 64-bit inferiors on x86_64 architectures,
+        // FXSAVE area can be written using PTRACE_SETFPREGS ptrace api
+        switch (target_arch.GetMachine ())
+        {
+            case llvm::Triple::x86:
+                return WriteRegisterSet(&m_iovec, sizeof(m_fpr.xstate.xsave), NT_PRXFPREG);
+            case llvm::Triple::x86_64:
                 return NativeRegisterContextLinux::WriteFPR();
+            default:
+                assert(false && "Unhandled target architecture.");
+                break;
+        }
     case FPRType::eFPRTypeXSAVE:
         return WriteRegisterSet(&m_iovec, sizeof(m_fpr.xstate.xsave), NT_X86_XSTATE);
     default:
         return Error("Unrecognized FPR type");
     }
 }
 
 bool
default:
         return 0;
     }
 }
 
 Error
 NativeRegisterContextLinux_x86_64::ReadFPR ()
 {
     const FPRType fpr_type = GetFPRType ();
+    const lldb_private::ArchSpec& target_arch = GetRegisterInfoInterface().GetTargetArchitecture();
     switch (fpr_type)
     {
     case FPRType::eFPRTypeFXSAVE:
+        // For 32-bit inferiors on x86_32/x86_64 architectures,
+        // FXSAVE area can be read using PTRACE_GETREGSET ptrace api
+        // For 64-bit inferiors on x86_64 architectures,
+        // FXSAVE area can be read using PTRACE_GETFPREGS ptrace api
+        switch (target_arch.GetMachine ())
+        {
+            case llvm::Triple::x86:
+                return ReadRegisterSet(&m_iovec, sizeof(m_fpr.xstate.xsave), NT_PRXFPREG);
+            case llvm::Triple::x86_64:
                 return NativeRegisterContextLinux::ReadFPR();
+            default:
+                assert(false && "Unhandled target architecture.");
+                break;
+        }
     case FPRType::eFPRTypeXSAVE:
         return ReadRegisterSet(&m_iovec, sizeof(m_fpr.xstate.xsave), NT_X86_XSTATE);
     default:
         return Error("Unrecognized FPR type");
     }
 }
 
 Error