Make llgs build on Android. No functionality change.

[tfiala]

Just to clarify for others and give context, Tong:

These are changes that allow llgs to build, within the AOSP source tree, using the Android.mk build system, when using the llvm/clang/lldb git repos from AOSP replaced with the experimental ones in github.com/tfiala/aosp-{llvm,clang,lldb}. Is that right, Tong?

[endlessroad]

In D5495#4, @tfiala wrote:

Just to clarify for others and give context, Tong:

These are changes that allow llgs to build, within the AOSP source tree, using the Android.mk build system, when using the llvm/clang/lldb git repos from AOSP replaced with the experimental ones in github.com/tfiala/aosp-{llvm,clang,lldb}. Is that right, Tong?

Yep :-) (also needs github.com/tfiala/aosp-compiler-rt)

[tfiala]

These are changes that allow llgs to build, within the AOSP source tree, using the Android.mk build system, when using the llvm/clang/lldb git repos from AOSP replaced with the experimental ones in github.com/tfiala/aosp-{llvm,clang,lldb}. Is that right, Tong?

Missed one - and aosp-compiler-rt.

Correct, Tong?

[tfiala]

Haha okay, jinx :-)

[tfiala]

LGTM.

We might later want to look at how/where we're constructing IOHandlerEditLine. It seems like it might first show up at too low a level of the stack based on your need to comment it out (unneeded in llgs and not wanting to bring in the libedit dependency).

I'll ping Greg to see if he wants somebody to look over before we approve and move this in.

[jingham]

I don't have time to look at this right now, but that's an awful lot of #ifndef ANDROID in places I wouldn't really expect these defines. Particularly the ones that deal with the IOHandlerEditLine. Either you're building stuff for llgs that you don't really need to (why does it need the command interpreter) or we really need a non-interactive configuration for the command interpreter that substitutes the EditLine I/O handler with one that is not interactive... Anyway, that part does seem ugly to me.

Also one of the uses of ANDROID is to not include some python goo, but there's already a "build without python" define for that purpose.

Jim

[tfiala]

I think part of our challenge is when we try to build remote pieces with
what is effectively lldb-core, we really could use at least a 2-layer
division of the core. The true low-level goo in a core, and some
higher-level bits that only the lldb client really needs but isn't needed
for a debug stub/monitor.

[endlessroad]

Absolutely true :-)

But in my remaining time I'm afraid that's not gonna happen...
So we can only do ANDROID tricks first, and then refactor...

[clayborg]

Yikes, I really don't like the "#ifndef ANDROID" stuff everywhere. That will encourage others to do the same kind of thing. We should make a LLDB_NO_EDITLINE or some other define.

the IOHandlerEditline class does have support for non-editline based input. It uses this when the input file handle isn't interactive. You should actually leave the IOHandlerEditline class in and use the LLDB_NO_EDITLINE define to leave the actual editline based code out and always for it to use the file descriptor methods.

then the changes in files that were disabling the IOHandlerEditline are not needed.

size_t
FileSpec::ResolvePartialUsername (const char *partial_name, StringList &matches)
{
#if defined(LLDB_CONFIG_TILDE_RESOLVES_TO_USER) && !defined(ANDROID)

size_t extant_entries = matches.GetSize();

setpwent();

This:

#ifdef ANDROID
// Android does not have SUN_LEN
#ifndef SUN_LEN
#define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) + strlen((ptr)->sun_path))
#endif
#endif

Can just become:

#ifndef SUN_LEN
#define SUN_LEN(ptr) ((size_t) (((struct sockaddr_un *) 0)->sun_path) + strlen((ptr)->sun_path))
#endif

But this should probably be only moved to the files that need it. "Host.h" seems like too public of a place for this kind of specific stuff.

All #include changes where a more descriptive path are given are fine.

The changes in lldb-gdbserver.cpp:

#ifndef ANDROID
#include "lldb/lldb-python.h"
#endif

Should be removed and us the #define that disables python.

Why do we need to #include <spawn.h> in "ProcessGDBRemote.cpp"? Seems like we shouldn't need that anymore and the change in ProcessGDBRemote.cpp should be removed.

The change in FileSpec.cpp:

#if defined(LLDB_CONFIG_TILDE_RESOLVES_TO_USER) && !defined(ANDROID)

should not be here. The LLDB_CONFIG_TILDE_RESOLVES_TO_USER should not be defined for android builds.

All preprocessor check in common/Host.cpp are ok since this is a host file. But in general, there should be minimal android checks in non-host code.

Check all places that are including <spawn.h> and try to reroute these to use Host code. I am guessing a lot of places that include it no longer need to.

[tfiala]

Sorry Tong, should have looked more closely at the Python part --- I thought we were already excluding Python and some of these fell out after that.

RE: this patch or follow up, we don't want a quick check-in that needs a rework, let's get it right the first time. (I see you're already working on that).

Basically Greg's comments :-)

Thanks, Tong!

[zturner]

source/Host/common/Host.cpp

978–980

If launching a process via posix_spawn() isn't supported on Android, then how *do* you launch a process on Android?

source/Host/posix/HostInfoPosix.cpp

98–100

Is this unsupported on Android because it doesn't compile, or for some other reason? Also, Android implies Linux right? If so, this check is better in HostInfoLinux

source/Host/posix/HostThreadPosix.cpp

53–58

Same as before. Is this unsupported because it doesn't compile, or for some other reason? Also more appropriate in HostThreadLinux.

[zturner]

I also want to echo all the comments that I really don't like the #ifdefs everywhere. I've been working for the past 2 months specifically to get rid of #ifdefs, so this is like a punch in the stomach :(

[endlessroad]

Eventually there should be separate files for Android.

I just want to post a quick patch to let it build on Android first.

Cleanups on the way.

source/Host/common/Host.cpp

978–980

No launching; attaching only.

source/Host/posix/HostInfoPosix.cpp

98–100

Android uses its own C library, which does not provide getgrgid_r()

source/Host/posix/HostThreadPosix.cpp

53–58

Same as before

[zturner]

In D5495#21, @endlessroad wrote:

Eventually there should be separate files for Android.

I just want to post a quick patch to let it build on Android first.

Cleanups on the way.

I'll defer to Greg and Jim about whether they will accept all the #ifdefs. But regardless, assuming Android implies Linux (which I believe it does) please move the Android specific checks to HostThreadLinux and HostInfoLinux.

[endlessroad]

• Add macro LLDB_DISABLE_LIBEDIT instead of using "#ifndef ANDROID" in IOHandler related changes
• Remove some unused include (<spawn.h>, "lldb-python.h")
• Unset LLDB_CONFIG_TILDE_RESOLVES_TO_USER for android
• Move android specific SUN_LEN definition to source/Host/Socket.cpp

[zturner]

I'm not seeing the changes to HostInfoPosix and HostThreadPosix that I
suggested. Are those still coming in a followup?

[tfiala]

In D5495#27, @zturner wrote:

I'm not seeing the changes to HostInfoPosix and HostThreadPosix that I
suggested. Are those still coming in a followup?

With Android, it's *mostly* Linux (at the kernel level) except we have a whole slew of different runtime libraries that differ. So, for much of the behavior, it will be like Linux/POSIX, but with certain libc calls and whatnot that just don't exist. Ideally we minimize how much we differ and only when needed.

Tong, can you take a look at that? If we need a Linux-derived Android variant of these classes, this might be a good time to look at those. Thanks.

(paraphrased) how do you launch on Android, then?

In general you don't. The Android zygote takes care of launching for userland, and debuggers usually run attach-only.

That's just a half-truth, though. We do have low-level, internal capabilities for launching, but since that is not a supported path for developers, they are not exposed in a way we can access with POSIX-like calls. The launch code might end up only showing up in an AOSP environment but, in any event, the attach path is the crucial one for Android right now.

[endlessroad]

Add Host{Info, Thread}Android. They cannot directly inherit Host{Info, Thread}Posix, because that would need linking the base classes, which will cause linker error (some POSIX functions do not exist on Android)

[zturner]

In D5495#29, @endlessroad wrote:

Add Host{Info, Thread}Android. They cannot directly inherit Host{Info, Thread}Posix, because that would need linking the base classes, which will cause linker error (some POSIX functions do not exist on Android)

It didn't occur to me that there would be linker errors. As a result, I think your original solution of putting the #ifdef in Host[Info/Thread]Posix.cpp is probably better than this. This results in a lot of code duplication as well, I'm fine with undoing these changes and going back to your original patch. Sorry for the trouble.

[endlessroad]

Reupload DIff version 4.

Hi Jim, Greg,

All your original comments have been addressed.

[tfiala]

I'll review and get these in over the weekend unless I hear major objections.

-Todd

[tfiala]

Hey Tong,

What are all the flags you assume are set when building this on the Android side? In addition to building it with stock normal flags on Linux, I want to use the same flag set.

Looks like the define flag set includes at least:
LLDB_DISABLE_LIBEDIT
LLDB_DISABLE_PYTHON
(and of course from the compiler, ANDROID).

Anything else?

-Todd

[tfiala]

Hey Tong,

So I was looking through the LLVM/Clang code at their LIBEDIT support (which I vaguely remember going in or being tweaked in the last half year or so). There is a HAVE_LIBEDIT flag that is defined if libedit is present. While it makes sense for us to be able to disable lldb's libedit support when HAVE_LIBEDIT is true, we certainly *do* want to turn on LLDB_DISABLE_LIBEDIT when HAVE_LIBEDIT is not defined.

I think that can happen as a follow-up patch. It would be great if you could work that in later.

[tfiala]

LGTM. Much cleaner than first pass. Thanks, Tong, and thanks others for the constructive feedback!

[tfiala]

svn commit
Sending include/lldb/Core/IOHandler.h
Sending include/lldb/Host/linux/Config.h
Sending source/Core/IOHandler.cpp
Sending source/Host/common/Host.cpp
Sending source/Host/common/Socket.cpp
Sending source/Host/linux/Host.cpp
Sending source/Host/posix/HostInfoPosix.cpp
Sending source/Host/posix/HostThreadPosix.cpp
Sending source/Interpreter/CommandInterpreter.cpp
Sending source/Plugins/Process/Linux/LinuxThread.h
Sending source/Plugins/Process/Linux/NativeProcessLinux.cpp
Sending source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.h
Sending source/Plugins/Process/Linux/ProcessLinux.cpp
Sending source/Plugins/Process/Linux/ProcessLinux.h
Sending source/Plugins/Process/Linux/ProcessMonitor.cpp
Sending source/Plugins/Process/POSIX/POSIXThread.cpp
Sending source/Plugins/Process/POSIX/POSIXThread.h
Sending source/Plugins/Process/POSIX/ProcessPOSIX.cpp
Sending source/Plugins/Process/POSIX/RegisterContextPOSIXProcessMonitor_arm64.cpp
Sending source/Plugins/Process/POSIX/RegisterContextPOSIXProcessMonitor_mips64.cpp
Sending source/Plugins/Process/POSIX/RegisterContextPOSIXProcessMonitor_x86.cpp
Sending source/Plugins/Process/Utility/RegisterInfos_arm64.h
Sending source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp
Sending source/Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.cpp
Sending source/Plugins/Process/elf-core/ThreadElfCore.cpp
Sending source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
Sending source/Target/ProcessLaunchInfo.cpp
Sending source/Target/Thread.cpp
Sending tools/lldb-gdbserver/lldb-gdbserver.cpp
Transmitting file data .............................
Committed revision 218568.

include/lldb/Core/IOHandler.h

         const std::string m_end_line;
     };
     
-    
+#ifndef __ANDROID__
     class IOHandlerEditline : public IOHandler
     {
     public:

     protected:
         ValueObjectList m_valobj_list;
     };
+#endif
 
     class IOHandlerStack
     {

source/Commands/CommandObjectCommands.cpp

 
             if (argc == 1)
             {
+#ifndef __ANDROID__
                 Debugger &debugger = m_interpreter.GetDebugger();
                 const bool multiple_lines = true; // Get multiple lines
                 IOHandlerSP io_handler_sp (new IOHandlerEditline (debugger,

                     debugger.PushIOHandler(io_handler_sp);
                     result.SetStatus (eReturnStatusSuccessFinishNoResult);
                 }
+#else
+                assert(false && "IOHandlerEditline not supported on Android");
+#endif
             }
             else
             {

source/Commands/CommandObjectExpression.cpp

 void
 CommandObjectExpression::GetMultilineExpression ()
 {
+#ifndef __ANDROID__
     m_expr_lines.clear();
     m_expr_line_count = 0;
     

         output_sp->Flush();
     }
     debugger.PushIOHandler(io_handler_sp);
+#else
+    assert(false && "IOHandlerEditline not supported on Android");
+#endif
 }
 
 bool

source/Core/IOHandler.cpp

 #include "lldb/Core/State.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObjectRegister.h"
+#ifndef __ANDROID__
 #include "lldb/Host/Editline.h"
+#endif
 #include "lldb/Interpreter/CommandCompletions.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Symbol/Block.h"

     return GetInputStreamFile()->GetFile().GetIsRealTerminal();
 }
 
+#ifndef __ANDROID__
 IOHandlerConfirm::IOHandlerConfirm (Debugger &debugger,
                                     const char *prompt,
                                     bool default_response) :

         io_handler.SetIsDone(true);
     }
 }
+#endif
 
 int
 IOHandlerDelegate::IOHandlerComplete (IOHandler &io_handler,

     return 0;
 }
 
-
+#ifndef __ANDROID__
 IOHandlerEditline::IOHandlerEditline (Debugger &debugger,
                                       const char *editline_name, // Used for saving history files
                                       const char *prompt,

 }
 
 #endif // #ifndef LLDB_DISABLE_CURSES
+
+#endif // #ifndef __ANDROID__

source/Host/common/FileSpec.cpp

 size_t
 FileSpec::ResolvePartialUsername (const char *partial_name, StringList &matches)
 {
-#ifdef LLDB_CONFIG_TILDE_RESOLVES_TO_USER
+#if defined(LLDB_CONFIG_TILDE_RESOLVES_TO_USER) && !defined(__ANDROID__)
     size_t extant_entries = matches.GetSize();
     
     setpwent();

source/Host/common/Host.cpp

 #include <sys/stat.h>
 #endif
 
-#if !defined (__GNU__) && !defined (_WIN32)
-// Does not exist under GNU/HURD or Windows
+#if !defined (__GNU__) && !defined (_WIN32) && !defined (__ANDROID__)
+// Does not exist under GNU/HURD, or Windows, or Android
 #include <sys/sysctl.h>
 #endif
 

 #endif
 
 #if defined (__linux__) || defined (__FreeBSD__) || defined (__FreeBSD_kernel__) || defined (__APPLE__) || defined(__NetBSD__)
+#ifndef __ANDROID__
 #include <spawn.h>
+#endif
 #include <sys/wait.h>
 #include <sys/syscall.h>
 #endif

     return ThreadLauncher::LaunchThread(thread_name, MonitorChildProcessThreadFunction, info_ptr, NULL);
 }
 
+#ifndef __ANDROID__
 //------------------------------------------------------------------
 // Scoped class that will disable thread canceling when it is
 // constructed, and exception safely restore the previous value it

 private:
     int m_old_state;    // Save the old cancelability state.
 };
+#endif
 
 static thread_result_t
 MonitorChildProcessThreadFunction (void *arg)

             log->Printf("%s ::wait_pid (pid = %" PRIi32 ", &status, options = %i)...", function, pid, options);
 
         // Wait for all child processes
+#ifndef __ANDROID__
         ::pthread_testcancel ();
+#endif
         // Get signals from all children with same process group of pid
         const ::pid_t wait_pid = ::waitpid (pid, &status, options);
+#ifndef __ANDROID__
         ::pthread_testcancel ();
+#endif
 
         if (wait_pid == -1)
         {

 
             // Scope for pthread_cancel_disabler
             {
+#ifndef __ANDROID__
                 ScopedPThreadCancelDisabler pthread_cancel_disabler;
+#endif
 
                 log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_PROCESS);
                 if (log)

 Host::GetModuleFileSpecForHostAddress (const void *host_addr)
 {
     FileSpec module_filespec;
+#ifndef __ANDROID__
     Dl_info info;
     if (::dladdr (host_addr, &info))
     {
         if (info.dli_fname)
             module_filespec.SetFile(info.dli_fname, true);
     }
+#else
+    assert(false && "dladdr() not supported on Android");
+#endif
     return module_filespec;
 }
 

 short
 Host::GetPosixspawnFlags (ProcessLaunchInfo &launch_info)
 {
+#ifndef __ANDROID__
     short flags = POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK;
 
 #if defined (__APPLE__)

 #endif
 #endif // #if defined (__APPLE__)
     return flags;
+#else
+    assert(false *&& "Host::GetPosixspawnFlags() not supported on Android");
+    return 0;
+#endif
 }
 
 Error
 Host::LaunchProcessPosixSpawn (const char *exe_path, ProcessLaunchInfo &launch_info, ::pid_t &pid)
 {
     Error error;
+#ifndef __ANDROID__
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_HOST | LIBLLDB_LOG_PROCESS));
 
     posix_spawnattr_t attr;

         }
 #endif
     }
+#else
+    error.SetErrorString("Host::LaunchProcessPosixSpawn() not supported on Android");
+#endif
 
     return error;
 }

 bool
 Host::AddPosixSpawnFileAction(void *_file_actions, const FileAction *info, Log *log, Error &error)
 {
+#ifndef __ANDROID__
     if (info == NULL)
         return false;
 

             break;
     }
     return error.Success();
+#else
+    error.SetErrorString("Host::AddPosixSpawnFileAction() not supported on Android");
+    return false;
+#endif
 }
 
 #endif // LaunchProcedssPosixSpawn: Apple, Linux, FreeBSD and other GLIBC systems

source/Host/linux/Host.cpp

 #include <sys/stat.h>
 #include <dirent.h>
 #include <fcntl.h>
+#ifndef __ANDROID__
 #include <execinfo.h>
+#endif
 
 // C++ Includes
 // Other libraries and framework includes

 void
 Host::Backtrace (Stream &strm, uint32_t max_frames)
 {
+#ifndef __ANDROID__
     if (max_frames > 0)
     {
         std::vector<void *> frame_buffer (max_frames, NULL);

             ::free (strs);
         }
     }
+#else
+    assert(false && "::backtrace() not supported on Android");
+#endif
 }
 
 size_t

source/Host/posix/HostInfoPosix.cpp

 const char *
 HostInfoPosix::LookupGroupName(uint32_t gid, std::string &group_name)
 {
+#ifndef __ANDROID__
     char group_buffer[PATH_MAX];
     size_t group_buffer_size = sizeof(group_buffer);
     struct group group_info;

         }
     }
     group_name.clear();
+#else
+    assert(false && "getgrgid_r() not supported on Android");
+#endif
     return NULL;
 }
 

source/Host/posix/HostThreadPosix.cpp

 HostThreadPosix::Cancel()
 {
     Error error;
+#ifndef __ANDROID__
     int err = ::pthread_cancel(m_thread);
     error.SetError(err, eErrorTypePOSIX);
+#else
+    error.SetErrorString("HostThreadPosix::Cancel() not supported on Android");
+#endif
 
     return error;
 }

source/Interpreter/CommandInterpreter.cpp

 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Timer.h"
 
+#ifndef __ANDROID__
 #include "lldb/Host/Editline.h"
+#endif
 #include "lldb/Host/Host.h"
 #include "lldb/Host/HostInfo.h"
 

 bool 
 CommandInterpreter::Confirm (const char *message, bool default_answer)
 {
+#ifndef __ANDROID__
     // Check AutoConfirm first:
     if (m_debugger.GetAutoConfirm())
         return default_answer;

     IOHandlerSP io_handler_sp (confirm);
     m_debugger.RunIOHandler (io_handler_sp);
     return confirm->GetResponse();
+#else
+    assert(false && "IOHandlerConfirm not supported on Android");
+    return false;
+#endif
 }
     
 OptionArgVectorSP

                                             LazyBool add_to_history,
                                             CommandReturnObject &result)
 {
+#ifndef __ANDROID__
     if (cmd_file.Exists())
     {
         StreamFileSP input_file_sp (new StreamFile());

         result.SetStatus (eReturnStatusFailed);
         return;
     }
+#else
+    assert(false && "IOHandlerEditline not supported on Android");
+#endif
 }
 
 ScriptInterpreter *

                                                   bool asynchronously,
                                                   void *baton)
 {
+#ifndef __ANDROID__
     Debugger &debugger = GetDebugger();
     IOHandlerSP io_handler_sp (new IOHandlerEditline (debugger,
                                                       "lldb",       // Name of input reader for history

         else
             debugger.RunIOHandler(io_handler_sp);
     }
-    
+#else
+    assert(false && "IOHandlerEditline not supported on Android");
+#endif
 }
 
 

                                                     bool asynchronously,
                                                     void *baton)
 {
+#ifndef __ANDROID__
     Debugger &debugger = GetDebugger();
     IOHandlerSP io_handler_sp (new IOHandlerEditline (debugger,
                                                       "lldb-python",    // Name of input reader for history

         else
             debugger.RunIOHandler(io_handler_sp);
     }
-
+#else
+    assert(false && "IOHandlerEditline not supported on Android");
+#endif
 }
 
 bool

 CommandInterpreter::RunCommandInterpreter(bool auto_handle_events,
                                           bool spawn_thread)
 {
+#ifndef __ANDROID__
     // Only get one line at a time
     const bool multiple_lines = false;
     

         if (auto_handle_events)
             m_debugger.StopEventHandlerThread();
     }
-
+#else
+    assert(false && "IOHandlerEditline not supported on Android");
+#endif
 }
 

source/Plugins/Process/Linux/LinuxThread.h

 #define liblldb_LinuxThread_H_
 
 // Other libraries and framework includes
-#include "POSIXThread.h"
+#include "Plugins/Process/POSIX/POSIXThread.h"
 
 //------------------------------------------------------------------------------
 // @class LinuxThread

source/Plugins/Process/Linux/NativeProcessLinux.cpp

 #include <unistd.h>
 #include <linux/unistd.h>
 #include <sys/personality.h>
+#ifndef __ANDROID__
 #include <sys/procfs.h>
+#endif
 #include <sys/ptrace.h>
 #include <sys/uio.h>
 #include <sys/socket.h>

 #include "Plugins/Process/Utility/LinuxSignals.h"
 #include "NativeThreadLinux.h"
 #include "ProcFileReader.h"
-#include "ProcessPOSIXLog.h"
+#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
+
+#ifdef __ANDROID__
+#define __ptrace_request int
+#define PT_DETACH PTRACE_DETACH
+#endif
 
 #define DEBUG_PTRACE_MAXBYTES 20
 

source/Plugins/Process/Linux/NativeRegisterContextLinux_x86_64.h

 #define lldb_NativeRegisterContextLinux_x86_64_h
 
 #include "lldb/Target/NativeRegisterContextRegisterInfo.h"
-#include "RegisterContext_x86.h"
-#include "lldb-x86-register-enums.h"
+#include "Plugins/Process/Utility/RegisterContext_x86.h"
+#include "Plugins/Process/Utility/lldb-x86-register-enums.h"
 
 namespace lldb_private
 {

source/Plugins/Process/Linux/ProcessLinux.h

 
 // Other libraries and framework includes
 #include "lldb/Target/Process.h"
-#include "ProcessMessage.h"
-#include "ProcessPOSIX.h"
+#include "Plugins/Process/POSIX/ProcessMessage.h"
+#include "Plugins/Process/POSIX/ProcessPOSIX.h"
 
 class ProcessMonitor;
 

source/Plugins/Process/Linux/ProcessLinux.cpp

 #include "lldb/Target/Target.h"
 
 #include "ProcessLinux.h"
-#include "ProcessPOSIXLog.h"
+#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
 #include "Plugins/Process/Utility/LinuxSignals.h"
 #include "ProcessMonitor.h"

source/Plugins/Process/Linux/ProcessMonitor.cpp

 #include <unistd.h>
 #include <elf.h>
 #include <sys/personality.h>
+#ifndef __ANDROID__
 #include <sys/procfs.h>
+#endif
 #include <sys/ptrace.h>
 #include <sys/uio.h>
 #include <sys/socket.h>

 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Utility/PseudoTerminal.h"
 
-#include "POSIXThread.h"
+#include "Plugins/Process/POSIX/POSIXThread.h"
 #include "ProcessLinux.h"
-#include "ProcessPOSIXLog.h"
+#include "Plugins/Process/POSIX/ProcessPOSIXLog.h"
 #include "ProcessMonitor.h"
 
+#ifdef __ANDROID__
+#define __ptrace_request int
+#define PT_DETACH PTRACE_DETACH
+#endif
+
 #define DEBUG_PTRACE_MAXBYTES 20
 
 // Support ptrace extensions even when compiled without required kernel support

source/Plugins/Process/POSIX/POSIXThread.h

 
 // Other libraries and framework includes
 #include "lldb/Target/Thread.h"
-#include "RegisterContextPOSIX.h"
+#include "Plugins/Process/Utility/RegisterContextPOSIX.h"
 
 class ProcessMessage;
 class ProcessMonitor;

source/Plugins/Process/POSIX/POSIXThread.cpp

 #include "POSIXThread.h"
 #include "ProcessPOSIX.h"
 #include "ProcessPOSIXLog.h"
-#include "ProcessMonitor.h"
+#include "Plugins/Process/Linux/ProcessMonitor.h"
 #include "RegisterContextPOSIXProcessMonitor_arm64.h"
 #include "RegisterContextPOSIXProcessMonitor_mips64.h"
 #include "RegisterContextPOSIXProcessMonitor_x86.h"
-#include "RegisterContextLinux_arm64.h"
-#include "RegisterContextLinux_i386.h"
-#include "RegisterContextLinux_x86_64.h"
-#include "RegisterContextFreeBSD_i386.h"
-#include "RegisterContextFreeBSD_mips64.h"
-#include "RegisterContextFreeBSD_x86_64.h"
-
-#include "UnwindLLDB.h"
+#include "Plugins/Process/Utility/RegisterContextLinux_arm64.h"
+#include "Plugins/Process/Utility/RegisterContextLinux_i386.h"
+#include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
+#include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h"
+#include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h"
+#include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h"
+#include "Plugins/Process/Utility/UnwindLLDB.h"
 
 using namespace lldb;
 using namespace lldb_private;

source/Plugins/Process/POSIX/ProcessPOSIX.cpp

 #include "ProcessPOSIX.h"
 #include "ProcessPOSIXLog.h"
 #include "Plugins/Process/Utility/InferiorCallPOSIX.h"
-#include "ProcessMonitor.h"
+#include "Plugins/Process/Linux/ProcessMonitor.h"
 #include "POSIXThread.h"
 
 using namespace lldb;

source/Plugins/Process/POSIX/RegisterContextPOSIXProcessMonitor_arm64.cpp

 #include "lldb/Target/Thread.h"
 #include "lldb/Core/RegisterValue.h"
 
-#include "RegisterContextPOSIX_arm64.h"
+#include "Plugins/Process/Utility/RegisterContextPOSIX_arm64.h"
 #include "ProcessPOSIX.h"
 #include "RegisterContextPOSIXProcessMonitor_arm64.h"
-#include "ProcessMonitor.h"
+#include "Plugins/Process/Linux/ProcessMonitor.h"
 
 #define REG_CONTEXT_SIZE (GetGPRSize())
 

source/Plugins/Process/POSIX/RegisterContextPOSIXProcessMonitor_mips64.cpp

 #include "lldb/Target/Thread.h"
 #include "lldb/Core/RegisterValue.h"
 
-#include "RegisterContextPOSIX_mips64.h"
+#include "Plugins/Process/Utility/RegisterContextPOSIX_mips64.h"
 #include "ProcessPOSIX.h"
 #include "RegisterContextPOSIXProcessMonitor_mips64.h"
-#include "ProcessMonitor.h"
+#include "Plugins/Process/Linux/ProcessMonitor.h"
 
 using namespace lldb_private;
 using namespace lldb;

source/Plugins/Process/POSIX/RegisterContextPOSIXProcessMonitor_x86.cpp

 #include "lldb/Target/Thread.h"
 #include "lldb/Core/RegisterValue.h"
 
-#include "ProcessPOSIX.h"
+#include "Plugins/Process/POSIX/ProcessPOSIX.h"
 #include "RegisterContextPOSIXProcessMonitor_x86.h"
-#include "ProcessMonitor.h"
+#include "Plugins/Process/Linux/ProcessMonitor.h"
 
 using namespace lldb_private;
 using namespace lldb;

         return (0x2 << 2) | rw;
     default:
         assert(0 && "invalid size, must be one of 1, 2, 4, or 8");
+        return 0;
     }
 }
 

source/Plugins/Process/Utility/RegisterInfos_arm64.h

 #include "lldb/lldb-defines.h"
 #include "lldb/lldb-enumerations.h"
 
-#include "ARM64_GCC_Registers.h"
-#include "ARM64_DWARF_Registers.h"
+#include "Utility/ARM64_GCC_Registers.h"
+#include "Utility/ARM64_DWARF_Registers.h"
 
 #ifndef GPR_OFFSET
 #error GPR_OFFSET must be defined before including this header file

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_mips64.cpp

 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
-#include "RegisterContextPOSIX.h"
+#include "Plugins/Process/Utility/RegisterContextPOSIX.h"
 #include "RegisterContextPOSIXCore_mips64.h"
 
 using namespace lldb_private;

source/Plugins/Process/elf-core/RegisterContextPOSIXCore_x86_64.cpp

 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Target/Thread.h"
-#include "RegisterContextPOSIX.h"
+#include "Plugins/Process/Utility/RegisterContextPOSIX.h"
 #include "RegisterContextPOSIXCore_x86_64.h"
 
 using namespace lldb_private;

source/Plugins/Process/elf-core/ThreadElfCore.cpp

 
 #include "ThreadElfCore.h"
 #include "ProcessElfCore.h"
-#include "RegisterContextLinux_x86_64.h"
-#include "RegisterContextFreeBSD_i386.h"
-#include "RegisterContextFreeBSD_mips64.h"
-#include "RegisterContextFreeBSD_x86_64.h"
+#include "Plugins/Process/Utility/RegisterContextLinux_x86_64.h"
+#include "Plugins/Process/Utility/RegisterContextFreeBSD_i386.h"
+#include "Plugins/Process/Utility/RegisterContextFreeBSD_mips64.h"
+#include "Plugins/Process/Utility/RegisterContextFreeBSD_x86_64.h"
 #include "RegisterContextPOSIXCore_mips64.h"
 #include "RegisterContextPOSIXCore_x86_64.h"
 

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

 #include <errno.h>
 #include <stdlib.h>
 #ifndef LLDB_DISABLE_POSIX
+#ifndef __ANDROID__
 #include <spawn.h>
+#endif
 #include <netinet/in.h>
 #include <sys/mman.h>       // for mmap
 #endif

source/Target/ProcessLaunchInfo.cpp

 
 #include "lldb/Host/Config.h"
 
+#ifndef __ANDROID__
 #ifndef LLDB_DISABLE_POSIX
 #include <spawn.h>
 #endif
+#endif
 
 #include "lldb/Target/ProcessLaunchInfo.h"
 #include "lldb/Target/FileAction.h"

source/Target/Thread.cpp

 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Target/Unwind.h"
 #include "Plugins/Process/Utility/UnwindLLDB.h"
-#include "UnwindMacOSXFrameBackchain.h"
+#include "Plugins/Process/Utility/UnwindMacOSXFrameBackchain.h"
 
 
 using namespace lldb;

tools/lldb-gdbserver/lldb-gdbserver.cpp

 //
 //===----------------------------------------------------------------------===//
 
+#ifndef __ANDROID__
 #include "lldb/lldb-python.h"
+#endif
 
 // C Includes
 #include <errno.h>