Convert mmap options for target in InferiorCallMmap.

[flackr]

Summary

Converts the MAP_PRIVATE and MAP_ANON options to the target platform constants (on which the call runs) rather than using those of the compiled host.

[flackr]

Looking up the mmap function address from the symbol table seems to have started working - we should still load debug symbols when possible but that can be done in a separate change.

This change is pretty much the minimal required to get this working. The process is a ProcessGDBRemote, and the platform is a PlatformRemoteGDBServer so I think we still need to check the target architecture if we try to move this to the process / platform.

[labath]

In D9511#166440, @flackr wrote:

Looking up the mmap function address from the symbol table seems to have started working - we should still load debug symbols when possible but that can be done in a separate change.

This change is pretty much the minimal required to get this working. The process is a ProcessGDBRemote, and the platform is a PlatformRemoteGDBServer so I think we still need to check the target architecture if we try to move this to the process / platform.

If you do a "platform select remote-linux", the platform is (or should be) PlatformLinux, which contains a PlatformRemoteGDBServer as a member and then proxies all the operations to it, if it does not want special handling. E.g., PlatformLinux::GetProcessInfo is implemented like

if (IsHost())
{
    success = Platform::GetProcessInfo (pid, process_info);
}
else
{
    if (m_remote_platform_sp)
        success = m_remote_platform_sp->GetProcessInfo (pid, process_info); // This is a PlatformRemoteGDBServer
}

So I think you should be able to thread your handling through the platform.

[clayborg]

Looks good.

[flackr]

• Delegate to Platform to convert Mmap flags.
• Fix platform when running remote-linux from mac by hard-coding linux archs, previously used host binary arch spec (e.g. macosx when running from mac)

[flackr]

In D9511#166552, @labath wrote:

In D9511#166440, @flackr wrote:

Looking up the mmap function address from the symbol table seems to have started working - we should still load debug symbols when possible but that can be done in a separate change.

This change is pretty much the minimal required to get this working. The process is a ProcessGDBRemote, and the platform is a PlatformRemoteGDBServer so I think we still need to check the target architecture if we try to move this to the process / platform.

If you do a "platform select remote-linux", the platform is (or should be) PlatformLinux, which contains a PlatformRemoteGDBServer as a member and then proxies all the operations to it, if it does not want special handling. E.g., PlatformLinux::GetProcessInfo is implemented like

if (IsHost())
{
    success = Platform::GetProcessInfo (pid, process_info);
}
else
{
    if (m_remote_platform_sp)
        success = m_remote_platform_sp->GetProcessInfo (pid, process_info); // This is a PlatformRemoteGDBServer
}

So I think you should be able to thread your handling through the platform.

Okay, I had to hard-code the archs on Linux rather than use the host arch spec so that the PlatformLinux was considered "compatible" with the Linux target (previously was using the host arch - macosx). It looks like lots of the Platform::GetSupportedArchAtIndex use the host OS, which seems like the wrong thing to do when you may be targetting that platform as a remote platform - perhaps we should be hard-coding the arch specs of other OS's as well.

I added the convert method to Platform.h and everything seems to be working.

[labath]

lgtm. thanks for fixing this.

[clayborg]

Looks good.

include/lldb/Target/Platform.h

 // TODO pull NativeDelegate class out of NativeProcessProtocol so we
 // can just forward ref the NativeDelegate rather than include it here.
 #include "lldb/Host/common/NativeProcessProtocol.h"
 
 namespace lldb_private {
 
 class ModuleCache;
 
+    enum MmapFlags {
+      eMmapFlagsPrivate = 1,
+      eMmapFlagsAnon = 2
+    };
+
     class PlatformProperties : public Properties
     {
     public:
         static ConstString
         GetSettingName ();
 
         PlatformProperties();
 
//                Error &error) = 0;
         GetEnvironment (StringList &environment);
         
         virtual bool
         GetFileExists (const lldb_private::FileSpec& file_spec);
         
         virtual Error
         Unlink (const char *path);
 
+        virtual uint64_t
+        ConvertMmapFlagsToPlatform(unsigned flags);
+
         virtual bool
         GetSupportsRSync ()
         {
             return m_supports_rsync;
         }
         
         virtual void
         SetSupportsRSync(bool flag)

source/Plugins/Platform/Linux/PlatformLinux.h

public:
             NativeProcessProtocol::NativeDelegate &native_delegate,
             NativeProcessProtocolSP &process_sp) override;
 
         Error
         AttachNativeProcess (lldb::pid_t pid,
                              NativeProcessProtocol::NativeDelegate &native_delegate,
                              NativeProcessProtocolSP &process_sp) override;
 
+        uint64_t
+        ConvertMmapFlagsToPlatform(unsigned flags) override;
+
         static bool
         UseLlgsForLocalDebugging ();
 
     private:
         DISALLOW_COPY_AND_ASSIGN (PlatformLinux);
     };
 
 } // namespace platform_linux
 } // namespace lldb_private
 
 #endif  // liblldb_PlatformLinux_h_

source/Plugins/Platform/Linux/PlatformLinux.cpp

 //===-- PlatformLinux.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/lldb-python.h"
 
 #include "PlatformLinux.h"
 #include "lldb/Host/Config.h"
 
 // C Includes
 #include <stdio.h>
+#include <vector>
 #ifndef LLDB_DISABLE_POSIX
 #include <sys/utsname.h>
 #endif
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Breakpoint/BreakpointLocation.h"

 #include "lldb/Interpreter/Property.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Process.h"
 
 #if defined(__linux__)
 #include "../../Process/Linux/NativeProcessLinux.h"
 #endif
 
+// Define these constants from Linux mman.h for use when targetting
+// remote linux systems even when host has different values.
+#define MAP_PRIVATE 2
+#define MAP_ANON 0x20
+
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::platform_linux;
 
 static uint32_t g_initialize_count = 0;
 
 //------------------------------------------------------------------
 /// Code to handle the PlatformLinux settings
else
             match_count = m_remote_platform_sp->FindProcesses (match_info, process_infos);
     }
     return match_count;
 }
 
 bool
 PlatformLinux::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch)
 {
-    if (idx == 0)
-    {
-        arch = HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
-        return arch.IsValid();
-    }
-    else if (idx == 1)
-    {
-        // If the default host architecture is 64-bit, look for a 32-bit variant
-        ArchSpec hostArch = HostInfo::GetArchitecture(HostInfo::eArchKindDefault);
-        if (hostArch.IsValid() && hostArch.GetTriple().isArch64Bit())
-        {
-            arch = HostInfo::GetArchitecture(HostInfo::eArchKind32);
-            return arch.IsValid();
-        }
-    }
+    static std::vector<ArchSpec> architectures = {
+        ArchSpec("x86_64-unknown-linux-gnu"),
+        ArchSpec("i386-unknown-linux-gnu"),
+    };
+    if (idx >= architectures.size())
         return false;
+    arch = architectures[idx];
+    return true;
 }
 
 void
 PlatformLinux::GetStatus (Stream &strm)
 {
     Platform::GetStatus(strm);
 
 #ifndef LLDB_DISABLE_POSIX

 #else
     if (!IsHost ())
         return Error("PlatformLinux::%s (): cannot attach to a debug process when not the host", __FUNCTION__);
 
     // Launch it for debugging
     return process_linux::NativeProcessLinux::AttachToProcess (pid, native_delegate, process_sp);
 #endif
 }
+
+uint64_t
+PlatformLinux::ConvertMmapFlagsToPlatform(unsigned flags)
+{
+    uint64_t flags_platform = 0;
+    if (flags & eMmapFlagsPrivate)
+        flags_platform |= MAP_PRIVATE;
+    if (flags & eMmapFlagsAnon)
+        flags_platform |= MAP_ANON;
+    return flags_platform;
+}

source/Plugins/Process/Utility/InferiorCallPOSIX.h

 
 enum MmapProt {
   eMmapProtNone = 0,
   eMmapProtExec = 1,
   eMmapProtRead = 2,
   eMmapProtWrite = 4
 };
 
-enum MmapFlags {
-  eMmapFlagsPrivate = 1,
-  eMmapFlagsAnon = 2
-};
-
 bool InferiorCallMmap(Process *proc, lldb::addr_t &allocated_addr,
                       lldb::addr_t addr, lldb::addr_t length, unsigned prot,
                       unsigned flags, lldb::addr_t fd, lldb::addr_t offset);
 
 bool InferiorCallMunmap(Process *proc, lldb::addr_t addr, lldb::addr_t length);
 
 bool InferiorCall(Process *proc, const Address *address, lldb::addr_t &returned_func);
 
 }   // namespace lldb_private
 
 #endif  // lldb_InferiorCallPOSIX_h_

source/Plugins/Process/Utility/InferiorCallPOSIX.cpp

 //===-- InferiorCallPOSIX.cpp -----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InferiorCallPOSIX.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Platform.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/ThreadPlanCallFunction.h"
 #include "lldb/Host/Config.h"
 
 #ifndef LLDB_DISABLE_POSIX
 #include <sys/mman.h>
 #else
 // define them
 #define PROT_NONE 0
 #define PROT_READ 1
 #define PROT_WRITE 2
 #define PROT_EXEC 4
-#define MAP_PRIVATE 2
-#define MAP_ANON 0x1000
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
 bool
 lldb_private::InferiorCallMmap (Process *process,
                                 addr_t &allocated_addr,
if (count > 0)
               if (prot & eMmapProtExec)
                 prot_arg |= PROT_EXEC;
               if (prot & eMmapProtRead)
                 prot_arg |= PROT_READ;
               if (prot & eMmapProtWrite)
                 prot_arg |= PROT_WRITE;
             }
 
-            if (flags & eMmapFlagsPrivate)
-              flags_arg |= MAP_PRIVATE;
-            if (flags & eMmapFlagsAnon)
-              flags_arg |= MAP_ANON;
+            flags_arg = process->GetTarget().GetPlatform()->ConvertMmapFlagsToPlatform(flags);
 
             AddressRange mmap_range;
             if (sc.GetAddressRange(range_scope, 0, use_inline_block_range, mmap_range))
             {
                 ClangASTContext *clang_ast_context = process->GetTarget().GetScratchClangASTContext();
                 ClangASTType clang_void_ptr_type = clang_ast_context->GetBasicType(eBasicTypeVoid).GetPointerType();
                 lldb::addr_t args[] = { addr, length, prot_arg, flags_arg, fd, offset };
                 lldb::ThreadPlanSP call_plan_sp (new ThreadPlanCallFunction (*thread,

source/Target/Platform.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/Utils.h"
 #include "llvm/Support/FileSystem.h"
 
 #include "Utility/ModuleCache.h"
 
+// Define these constants from POSIX mman.h rather than include the file
+// so that they will be correct even when compiled on Linux.
+#define MAP_PRIVATE 2
+#define MAP_ANON 0x1000
+
 using namespace lldb;
 using namespace lldb_private;
 
 static uint32_t g_initialize_count = 0;
 
 // Use a singleton function for g_local_platform_sp to avoid init
 // constructors since LLDB is often part of a shared library
 static PlatformSP&

 
 Error
 Platform::Unlink (const char *path)
 {
     Error error("unimplemented");
     return error;
 }
 
-
+uint64_t
+Platform::ConvertMmapFlagsToPlatform(unsigned flags)
+{
+    uint64_t flags_platform = 0;
+    if (flags & eMmapFlagsPrivate)
+        flags_platform |= MAP_PRIVATE;
+    if (flags & eMmapFlagsAnon)
+        flags_platform |= MAP_ANON;
+    return flags_platform;
+}
 
 lldb_private::Error
 Platform::RunShellCommand (const char *command,           // Shouldn't be NULL
                            const char *working_dir,       // Pass NULL to use the current working directory
                            int *status_ptr,               // Pass NULL if you don't want the process exit status
                            int *signo_ptr,                // Pass NULL if you don't want the signal that caused the process to exit
                            std::string *command_output,   // Pass NULL if you don't want the command output
                            uint32_t timeout_sec)          // Timeout in seconds to wait for shell program to finish