Replace __ANDROID_NDK__ with simply ANDROID

[labath]

Summary

This replaces all the uses of the ANDROID_NDK define with ANDROID. This is a
preparatory step to remove our custom android toolchain file and rely on the
standard android NDK one instead. Our toolchain file defined both ANDROID and
ANDROID_NDK, while the NDK one just defines ANDROID. So, make things
consistent and just use ANDROID everywhere.

I haven't yet removed the cmake variable with the same name, as we will need to
do something completely different there -- NDK toolchain defines
CMAKE_SYSTEM_NAME to Android, while our current one pretends it's linux.

[danalbert]

cmake/platforms/Android.cmake

35–36

You're removing it a line before just to add it back?

__ANDROID__ is probably the one you want. That one is defined by Clang (and GCC if that matters) for any Android target, so no need to worry about dealing with it in cmake (or any other build system).

This isn't a concern right now, but if LLDB ever needed to become part of the Android platform build, ANDROID doesn't actually mean ANDROID; it gets set for host modules too :(

[labath]

Thanks for the suggestion. I'll try using __ANDROID__ instead.

cmake/platforms/Android.cmake

35–36

I have no idea who wrote this file, but a bit messy, and that's why I am trying to get rid of it. :)

I didn't know about the __ANDROID__ thing. I'll try using that instead (and yes, I'd still like this to compile with gcc -- that's what we are using currently, although we may switch once this is sorted out).

[tberghammer]

include/lldb/Core/RegularExpression.h

34

In most case you use "#ifdef". It would be nice to uniformalize

source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp

31

In most case you use "#ifdef". It would be nice to uniformalize

source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp

123

(unrelated): What does an ANDROID specific define do in a MacOSX specific file?

[labath]

Update to use ANDROID

[labath]

I've tried to unify this slightly, but sometimes further unification would make things inconsistent with surrounding preprocessor directives.

I was suprised by the presence of some of these ifdefs as well -- some of them seem completely unnecessary. I think that at some point I'll have to make another pass at this and clean them up.

[labath]

Remove ifdef in driver.cpp -- it is completely unnecessary

[labath]

A bit more cleanup.

cmake/platforms/Android.cmake

 if( IS_IN_TRY_COMPILE )
  # this seems necessary and works fine but I'm unsure if it breaks anything
  return()
 endif()
 
 set( CMAKE_SYSTEM_NAME Linux )
 include( CMakeForceCompiler )
 
 # flags and definitions
-remove_definitions( -DANDROID -D__ANDROID__ )
-add_definitions( -DANDROID -D__ANDROID_NDK__ -DLLDB_DISABLE_LIBEDIT )
+add_definitions( -DANDROID -DLLDB_DISABLE_LIBEDIT )
 set( ANDROID True )
 set( __ANDROID_NDK__ True )
 set( LLDB_DEFAULT_DISABLE_LIBEDIT True )
 
 # linking lldb-server statically for Android avoids the need to ship two
 # binaries (pie for API 21+ and non-pie for API 16-). It's possible to use
 # a non-pie shim on API 16-, but that requires lldb-server to dynamically export
 # its symbols, which significantly increases the binary size. Static linking, on

include/lldb/Core/RegularExpression.h

 
 inline int regexec(const llvm_regex_t *a, const char *b, size_t c,
                    llvm_regmatch_t d[], int e) {
   return llvm_regexec(a, b, c, d, e);
 }
 
 inline void regfree(llvm_regex_t *a) { llvm_regfree(a); }
 #else
-#if __ANDROID_NDK__
+#ifdef __ANDROID__
 #include <regex>
 #endif
 #include <regex.h>
 #endif
 #include <stdint.h>
 
 #include <string>
 #include <vector>

include/lldb/Host/Config.h

 //===-- Config.h ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_Config_h_
 #define liblldb_Config_h_
 
 #if defined(__APPLE__)
 
 #include "lldb/Host/macosx/Config.h"
 
-#elif defined(__ANDROID_NDK__)
+#elif defined(__ANDROID__)
 
 #include "lldb/Host/android/Config.h"
 
 #elif defined(__linux__) || defined(__GNU__)
 
 #include "lldb/Host/linux/Config.h"
 
 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__) ||                   \

include/lldb/Host/Editline.h

 #endif
 
 #include "lldb/Host/ConnectionFileDescriptor.h"
 #include "lldb/lldb-private.h"
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/editlinewin.h"
 #else
-#if !defined(__ANDROID_NDK__)
+#ifndef __ANDROID__
 #include <histedit.h>
 #endif
 #endif
 
 #include <mutex>
 #include <string>
 #include <vector>
 

include/lldb/Host/Host.h

static uint32_t FindProcesses(const ProcessInstanceInfoMatch &match_info,
                                 ProcessInstanceInfoList &proc_infos);
 
   typedef std::map<lldb::pid_t, bool> TidMap;
   typedef std::pair<lldb::pid_t, bool> TidPair;
   static bool FindProcessThreads(const lldb::pid_t pid, TidMap &tids_to_attach);
 
   static bool GetProcessInfo(lldb::pid_t pid, ProcessInstanceInfo &proc_info);
 
-#if defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) ||        \
-    defined(__GLIBC__) || defined(__NetBSD__)
-#if !defined(__ANDROID__) && !defined(__ANDROID_NDK__)
+#if (defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) ||       \
+     defined(__GLIBC__) || defined(__NetBSD__)) &&                             \
+    !defined(__ANDROID__)
 
   static short GetPosixspawnFlags(const ProcessLaunchInfo &launch_info);
 
   static Error LaunchProcessPosixSpawn(const char *exe_path,
                                        const ProcessLaunchInfo &launch_info,
                                        lldb::pid_t &pid);
 
   static bool AddPosixSpawnFileAction(void *file_actions,
                                       const FileAction *info, Log *log,
                                       Error &error);
 
-#endif // !defined(__ANDROID__) && !defined(__ANDROID_NDK__)
-#endif // defined (__APPLE__) || defined (__linux__) || defined (__FreeBSD__) ||
-       // defined (__GLIBC__) || defined(__NetBSD__)
+#endif
 
   static const lldb::UnixSignalsSP &GetUnixSignals();
 
   static Error LaunchProcess(ProcessLaunchInfo &launch_info);
 
   //------------------------------------------------------------------
   /// Perform expansion of the command-line for this launch info
   /// This can potentially involve wildcard expansion

include/lldb/Host/HostInfo.h

 /// context where the method doesn't make sense, will generate a compiler error.
 ///
 //----------------------------------------------------------------------
 
 #if defined(_WIN32)
 #include "lldb/Host/windows/HostInfoWindows.h"
 #define HOST_INFO_TYPE HostInfoWindows
 #elif defined(__linux__)
-#if defined(__ANDROID_NDK__)
+#if defined(__ANDROID__)
 #include "lldb/Host/android/HostInfoAndroid.h"
 #define HOST_INFO_TYPE HostInfoAndroid
 #else
 #include "lldb/Host/linux/HostInfoLinux.h"
 #define HOST_INFO_TYPE HostInfoLinux
 #endif
 #elif defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
 #include "lldb/Host/freebsd/HostInfoFreeBSD.h"

include/lldb/Host/Time.h

 //===-- Time.h --------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // Include system time headers, adding missing functions as necessary
 
 #ifndef liblldb_Host_Time_h_
 #define liblldb_Host_Time_h_
 
-#ifdef __ANDROID_NDK__
+#ifdef __ANDROID__
 #include <android/api-level.h>
 #endif
 
 #if defined(__ANDROID_API__) && __ANDROID_API__ < 21
 #include <time64.h>
 extern time_t timegm(struct tm *t);
 #else
 #include <time.h>
 #endif
 
 #endif // liblldb_Host_Time_h_

include/lldb/Host/linux/Personality.h

 //===-- Personality.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This file defines personality functions & structures
 
 #ifndef liblldb_Host_linux_Personality_h_
 #define liblldb_Host_linux_Personality_h_
 
-#ifdef __ANDROID_NDK__
+#ifdef __ANDROID__
 #include <android/api-level.h>
 #endif
 
 #if defined(__ANDROID_API__) && __ANDROID_API__ < 21
 #include <linux/personality.h>
 #else
 #include <sys/personality.h>
 #endif
 
 #endif // liblldb_Host_linux_Personality_h_

include/lldb/Host/posix/Fcntl.h

 //===-- Fcntl.h -------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // This file defines fcntl functions & structures
 
 #ifndef liblldb_Host_posix_Fcntl_h_
 #define liblldb_Host_posix_Fcntl_h_
 
-#ifdef __ANDROID_NDK__
+#ifdef __ANDROID__
 #include <android/api-level.h>
 #endif
 
 #include <fcntl.h>
 
 #if defined(__ANDROID_API__) && __ANDROID_API__ < 21
 #define F_DUPFD_CLOEXEC (F_LINUX_SPECIFIC_BASE + 6)
 #endif
 
 #endif // liblldb_Host_posix_Fcntl_h_

source/Host/common/Host.cpp

 #if defined(__APPLE__)
 #include <mach-o/dyld.h>
 #include <mach/mach_init.h>
 #include <mach/mach_port.h>
 #endif
 
 #if defined(__linux__) || defined(__FreeBSD__) ||                              \
     defined(__FreeBSD_kernel__) || defined(__APPLE__) || defined(__NetBSD__)
-#if !defined(__ANDROID__) && !defined(__ANDROID_NDK__)
+#if !defined(__ANDROID__)
 #include <spawn.h>
 #endif
 #include <sys/syscall.h>
 #include <sys/wait.h>
 #endif
 
 #if defined(__FreeBSD__)
 #include <pthread_np.h>
#if defined(__APPLE__)
   // Calling "mach_thread_self()" bumps the reference count on the thread
   // port, so we need to deallocate it. mach_task_self() doesn't bump the ref
   // count.
   thread_port_t thread_self = mach_thread_self();
   mach_port_deallocate(mach_task_self(), thread_self);
   return thread_self;
 #elif defined(__FreeBSD__)
   return lldb::tid_t(pthread_getthreadid_np());
-#elif defined(__ANDROID_NDK__)
+#elif defined(__ANDROID__)
   return lldb::tid_t(gettid());
 #elif defined(__linux__)
   return lldb::tid_t(syscall(SYS_gettid));
 #else
   return lldb::tid_t(pthread_self());
 #endif
 }
 

 
 bool Host::ResolveExecutableInBundle(FileSpec &file) { return false; }
 #endif
 
 #ifndef _WIN32
 
 FileSpec Host::GetModuleFileSpecForHostAddress(const void *host_addr) {
   FileSpec module_filespec;
-#if !defined(__ANDROID__) && !defined(__ANDROID_NDK__)
+#if !defined(__ANDROID__)
   Dl_info info;
   if (::dladdr(host_addr, &info)) {
     if (info.dli_fname)
       module_filespec.SetFile(info.dli_fname, true);
   }
 #endif
   return module_filespec;
 }
Error Host::RunShellCommand(const Args &args, const FileSpec &working_dir,
   return error;
 }
 
 // LaunchProcessPosixSpawn for Apple, Linux, FreeBSD and other GLIBC
 // systems
 
 #if defined(__APPLE__) || defined(__linux__) || defined(__FreeBSD__) ||        \
     defined(__GLIBC__) || defined(__NetBSD__)
-#if !defined(__ANDROID__) && !defined(__ANDROID_NDK__)
+#if !defined(__ANDROID__)
 // this method needs to be visible to macosx/Host.cpp and
 // common/Host.cpp.
 
 short Host::GetPosixspawnFlags(const ProcessLaunchInfo &launch_info) {
   short flags = POSIX_SPAWN_SETSIGDEF | POSIX_SPAWN_SETSIGMASK;
 
 #if defined(__APPLE__)
   if (launch_info.GetFlags().Test(eLaunchFlagExec))
else {
                             "fd=%i, path='%s', oflag=%i, mode=%i)",
                        static_cast<void *>(file_actions), info->GetFD(),
                        info->GetPath().str().c_str(), oflag, mode);
     }
     break;
   }
   return error.Success();
 }
-#endif // !defined(__ANDROID__) && !defined(__ANDROID_NDK__)
+#endif // !defined(__ANDROID__)
 #endif // defined (__APPLE__) || defined (__linux__) || defined (__FreeBSD__) ||
        // defined (__GLIBC__) || defined(__NetBSD__)
 
 #if defined(__linux__) || defined(__FreeBSD__) || defined(__GLIBC__) ||        \
     defined(__NetBSD__) || defined(_WIN32)
 // The functions below implement process launching via posix_spawn() for Linux,
 // FreeBSD and NetBSD.
 

source/Host/common/Socket.cpp

 #include <sys/socket.h>
 #include <sys/un.h>
 #endif
 
 #ifdef __linux__
 #include "lldb/Host/linux/AbstractSocket.h"
 #endif
 
-#ifdef __ANDROID_NDK__
+#ifdef __ANDROID__
 #include <arpa/inet.h>
 #include <asm-generic/errno-base.h>
 #include <bits/error_constants.h>
 #include <errno.h>
 #include <linux/tcp.h>
 #if defined(ANDROID_ARM_BUILD_STATIC) || defined(ANDROID_MIPS_BUILD_STATIC)
 #include <fcntl.h>
 #include <sys/syscall.h>
 #include <unistd.h>
 #endif // ANDROID_ARM_BUILD_STATIC || ANDROID_MIPS_BUILD_STATIC
-#endif // __ANDROID_NDK__
+#endif // __ANDROID__
 
 using namespace lldb;
 using namespace lldb_private;
 
 #if defined(_WIN32)
 typedef const char *set_socket_option_arg_type;
 typedef char *get_socket_option_arg_type;
 const NativeSocket Socket::kInvalidSocketValue = INVALID_SOCKET;

source/Host/linux/ProcessLauncherLinux.cpp

 #include <sys/wait.h>
 
 #include <sstream>
 
 using namespace lldb;
 using namespace lldb_private;
 
 static void FixupEnvironment(Args &env) {
-#ifdef __ANDROID_NDK__
+#ifdef __ANDROID__
   // If there is no PATH variable specified inside the environment then set the
   // path to /system/bin. It is required because the default path used by
   // execve() is wrong on android.
   static const char *path = "PATH=";
   for (auto &entry : env.entries()) {
     if (entry.ref.startswith(path))
       return;
   }

source/Host/posix/HostInfoPosix.cpp

if (h)
       s.assign(h->h_name);
     else
       s.assign(hostname);
     return true;
   }
   return false;
 }
 
-#ifdef __ANDROID_NDK__
+#ifdef __ANDROID__
 #include <android/api-level.h>
 #endif
 #if defined(__ANDROID_API__) && __ANDROID_API__ < 21
 #define USE_GETPWUID
 #endif
 
 #ifdef USE_GETPWUID
 static std::mutex s_getpwuid_lock;

source/Plugins/Language/CPlusPlus/CxxStringTypes.cpp

 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/ProcessStructReader.h"
 
 #include <algorithm>
 
-#if __ANDROID_NDK__
+#ifdef __ANDROID__
 #include <sys/types.h>
 #endif
 
 #include "lldb/Host/Time.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;

source/Plugins/ObjectContainer/BSD-Archive/ObjectContainerBSDArchive.cpp

 //===-- ObjectContainerBSDArchive.cpp ---------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ObjectContainerBSDArchive.h"
 
-#if defined(_WIN32) || defined(__ANDROID_NDK__)
+#if defined(_WIN32) || defined(__ANDROID__)
 // Defines from ar, missing on Windows
 #define ARMAG "!<arch>\n"
 #define SARMAG 8
 #define ARFMAG "`\n"
 
 typedef struct ar_hdr {
   char ar_name[16];
   char ar_date[12];

source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp

case sizeof(double):
         return true;
       }
       break;
 
 // TOOD: need a better way to detect when "long double" types are
 // the same bytes size as "double"
 #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__) &&       \
     !defined(_MSC_VER) && !defined(__mips__) && !defined(__powerpc__) &&       \
-    !defined(__ANDROID_NDK__)
+    !defined(__ANDROID__)
     case sizeof(long double):
       if (sizeof(long double) == sizeof(uint32_t)) {
         value.SetUInt32(reg_value, RegisterValue::eTypeLongDouble);
         return true;
       } else if (sizeof(long double) == sizeof(uint64_t)) {
         value.SetUInt64(reg_value, RegisterValue::eTypeLongDouble);
         return true;
       }

source/Utility/PseudoTerminal.cpp

 #include <stdlib.h>
 #include <string.h>
 #if defined(TIOCSCTTY)
 #include <sys/ioctl.h>
 #endif
 
 #include "lldb/Host/PosixApi.h"
 
-#if defined(__ANDROID_NDK__)
+#if defined(__ANDROID__)
 int posix_openpt(int flags);
 #endif
 
 using namespace lldb_utility;
 
 //----------------------------------------------------------------------
 // PseudoTerminal constructor
 //----------------------------------------------------------------------

tools/driver/Driver.cpp

 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 
 // Includes for pipe()
 #if defined(_WIN32)
 #include <fcntl.h>
 #include <io.h>
-#elif defined(__ANDROID_NDK__)
+#elif defined(__ANDROID__)
 #include <errno.h>
 #else
 #include <unistd.h>
 #endif
 
 #include <string>
 
 #include "lldb/API/SBBreakpoint.h"