lldb - __arm64__ vs __aarch64__ insanity

[pawelo]

Summary

It's started with simple program:

#ifdef i386
#warning this is i386
#else
#warning this is NOT i386
#endif

#ifdef x86_64
#warning this is x86_64
#else
#warning this is NOT x86_64
#endif

#ifdef aarch64
#warning this is aarch64
#else
#warning this is NOT aarch64
#endif

#ifdef arm64
#warning this is arm64
#else
#warning this is NOT arm64
#endif

#ifdef arm
#warning this is arm
#else
#warning this is NOT arm
#endif

When cross-compiling on Linux for AArch64 using Linaro toolchain, the pre-processor produces following output:
$ aarch64-linux-gnu-gcc-4.8.2 -Wall -c aarch64.c
aarch64.c:4:2: warning: #warning this is NOT i386 [-Wcpp]
#warning this is NOT i386

^

aarch64.c:10:2: warning: #warning this is NOT x86_64 [-Wcpp]
#warning this is NOT x86_64

^

aarch64.c:14:2: warning: #warning this is aarch64 [-Wcpp]
#warning this is aarch64

^

aarch64.c:22:2: warning: #warning this is NOT arm64 [-Wcpp]
#warning this is NOT arm64

^

aarch64.c:28:2: warning: #warning this is NOT arm [-Wcpp]
#warning this is NOT arm

^

I expect that other cross-compilers define arm64 instead of aarch64 (or both), so there's my patch that causes checking for both. This is all-or-nothing approach, I did not try to investigate whether any of the parts of affected code are compiled on Linux or MacOSX - I altered all places where arm64 was used.
Before applying, it's worth to try if it still builds for ARM64 on MacOSX.

[pawelo]

RNBDefs.h changed as requested.

[tfiala]

Hey Paul,

Are you attempting to build debugserver over there on the linaro Linux build? If so, you will definitely find it easier going the lldb-gdbserver route (in fact I will be working on this as well). Apple will be moving over to lldb-gdbserver as well, so I think it will be wasted energy trying to get RNB* and debugserver files building over there. It's all way Apple-specific.

[tfiala]

Looks good. I'll check in shortly.

[tfiala]

Sending source/Core/Error.cpp
Sending source/Host/common/Host.cpp
Sending source/Host/macosx/Host.mm
Sending source/Host/macosx/Symbols.cpp
Sending source/Interpreter/CommandInterpreter.cpp
Sending source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp
Sending source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp
Sending source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp
Sending source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp
Sending source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp
Sending source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp
Sending source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp
Sending test/functionalities/data-formatter/data-formatter-objc/main.m
Sending tools/debugserver/source/DNB.cpp
Sending tools/debugserver/source/DNBDefs.h
Sending tools/debugserver/source/MacOSX/MachThreadList.cpp
Sending tools/debugserver/source/MacOSX/arm/DNBArchImpl.cpp
Sending tools/debugserver/source/MacOSX/arm/DNBArchImpl.h
Sending tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.cpp
Sending tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.h
Sending tools/debugserver/source/RNBDefs.h
Sending tools/debugserver/source/RNBRemote.cpp
Transmitting file data ......................
Committed revision 212583.

[pawelo]

Hey Todd,

That's the plan. This patch is a merely step towards this - it just clears
all the confusion caused by this double naming used by different
toolchains.

source/Core/Error.cpp

 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "llvm/ADT/SmallVector.h"
 #include <cerrno>
 #include <cstdarg>
 
-#if (defined (__arm__) || defined (__arm64__)) && defined (__APPLE__)
+#if (defined (__arm__) || defined (__arm64__) || defined (__aarch64__)) && defined (__APPLE__)
 #include <SpringBoardServices/SpringBoardServer.h>
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 
 Error::Error ():
     m_code (0),

source/Host/common/Host.cpp

case ePathTypeSupportExecutableDir:
                     char resolved_path[PATH_MAX];
                     lldb_file_spec.GetPath(raw_path, sizeof(raw_path));
 
 #if defined (__APPLE__)
                     char *framework_pos = ::strstr (raw_path, "LLDB.framework");
                     if (framework_pos)
                     {
                         framework_pos += strlen("LLDB.framework");
-#if defined (__arm__) || defined (__arm64__)
+#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
                         // Shallow bundle
                         *framework_pos = '\0';
 #else
                         // Normal bundle
                         ::strncpy (framework_pos, "/Resources", PATH_MAX - (framework_pos - raw_path));
 #endif
                     }
 #endif  // #if defined (__APPLE__)

source/Host/macosx/Host.mm

#if defined (__APPLE__)
     }
 #endif
   return false;
 }
 
 lldb::pid_t
 Host::LaunchApplication (const FileSpec &app_file_spec)
 {
-#if defined (__arm__) || defined(__arm64__)
+#if defined (__arm__) || defined(__arm64__) || defined(__aarch64__)
     return LLDB_INVALID_PROCESS_ID;
 #else
     char app_path[PATH_MAX];
     app_file_spec.GetPath(app_path, sizeof(app_path));
 
     LSApplicationParameters app_params;
     ::memset (&app_params, 0, sizeof (app_params));
     app_params.flags = kLSLaunchDefaults | 
for (int i=0; i<num_retries; i++)
         case 0:
             if (bsd_info.pbi_status == SSTOP)
                 return true;
         }
         ::usleep (time_delta_usecs);
     }
     return false;
 }
-#if !defined(__arm__) && !defined(__arm64__)
+#if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
 
 //static lldb::pid_t
 //LaunchInNewTerminalWithCommandFile 
 //(
 //    const char **argv, 
 //    const char **envp,
 //    const char *working_dir,
 //    const ArchSpec *arch_spec,
//    }
     }
     ::unlink (unix_socket_name);
     [applescript release];
     if (pid != LLDB_INVALID_PROCESS_ID)
         launch_info.SetProcessID (pid);
     return error;
 }
 
-#endif // #if !defined(__arm__)
+#endif // #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
 
 
 // On MacOSX CrashReporter will display a string for each shared library if
 // the shared library has an exported symbol named "__crashreporter_info__".
 
 static Mutex&
 GetCrashReporterMutex ()
 {
Host::SetCrashDescription (const char *cstr)
     {
         __crashreporter_info__ = NULL;
     }
 }
 
 bool
 Host::OpenFileInExternalEditor (const FileSpec &file_spec, uint32_t line_no)
 {
-#if defined(__arm__) || defined(__arm64__)
+#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
     return false;
 #else
     // We attach this to an 'odoc' event to specify a particular selection
     typedef struct {
         int16_t   reserved0;  // must be zero
         int16_t   fLineNumber;
         int32_t   fSelStart;
         int32_t   fSelEnd;
#else
     {
         if (log)
             log->Printf("LSOpenURLsWithRole failed, error: %ld.\n", error);
 
         return false;
     }
 
     return true;
-#endif // #if !defined(__arm__)
+#endif // #if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
 }
 
 
 void
 Host::Backtrace (Stream &strm, uint32_t max_frames)
 {
     if (max_frames > 0)
     {
Host::LaunchProcess (ProcessLaunchInfo &launch_info)
     {
         launch_info.GetExecutableFile().GetPath (exe_path, sizeof(exe_path));
         error.SetErrorStringWithFormat ("executable doesn't exist: '%s'", exe_path);
         return error;
     }
     
     if (launch_info.GetFlags().Test (eLaunchFlagLaunchInTTY))
     {
-#if !defined(__arm__) && !defined(__arm64__)
+#if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__)
         return LaunchInNewTerminalWithAppleScript (exe_path, launch_info);
 #else
         error.SetErrorString ("launching a process in a new terminal is not supported on iOS devices");
         return error;
 #endif
     }
     
     ::pid_t pid = LLDB_INVALID_PROCESS_ID;

source/Host/macosx/Symbols.cpp

 #include "Host/macosx/cfcpp/CFCString.h"
 #include "mach/machine.h"
 
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm::MachO;
 
-#if !defined (__arm__) && !defined (__arm64__) // No DebugSymbols on the iOS devices
+#if !defined (__arm__) && !defined (__arm64__) && !defined (__aarch64__) // No DebugSymbols on the iOS devices
 extern "C" {
 
 CFURLRef DBGCopyFullDSYMURLForUUID (CFUUIDRef uuid, CFURLRef exec_url);
 CFDictionaryRef DBGCopyDSYMPropertyLists (CFURLRef dsym_url);
 
 }
 #endif
 
)
     int items_found = 0;
 
     if (out_exec_fspec)
         out_exec_fspec->Clear();
 
     if (out_dsym_fspec)
         out_dsym_fspec->Clear();
 
-#if !defined (__arm__) && !defined (__arm64__) // No DebugSymbols on the iOS devices
+#if !defined (__arm__) && !defined (__arm64__) && !defined (__aarch64__) // No DebugSymbols on the iOS devices
 
     const UUID *uuid = module_spec.GetUUIDPtr();
     const ArchSpec *arch = module_spec.GetArchitecturePtr();
 
     if (uuid && uuid->IsValid())
     {
         // Try and locate the dSYM file using DebugSymbols first
         const UInt8 *module_uuid = (const UInt8 *)uuid->GetBytes();
if (uuid && uuid->IsValid())
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
-#endif // #if !defined (__arm__)
+#endif // #if !defined (__arm__) && !defined (__arm64__) && !defined (__aarch64__)
 
     return items_found;
 }
 
 static bool
 LocateDSYMInVincinityOfExecutable (const ModuleSpec &module_spec, FileSpec &dsym_fspec)
 {
     const FileSpec *exec_fspec = module_spec.GetFileSpecPtr();

source/Interpreter/CommandInterpreter.cpp

CommandInterpreter::Initialize ()
     {
         AddAlias ("kill", cmd_obj_sp);
     }
     
     cmd_obj_sp = GetCommandSPExact ("process launch", false);
     if (cmd_obj_sp)
     {
         alias_arguments_vector_sp.reset (new OptionArgVector);
-#if defined (__arm__) || defined (__arm64__)
+#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
         ProcessAliasOptionsArgs (cmd_obj_sp, "--", alias_arguments_vector_sp);
 #else
         ProcessAliasOptionsArgs (cmd_obj_sp, "--shell=" LLDB_DEFAULT_SHELL " --", alias_arguments_vector_sp);
 #endif
         AddAlias ("r", cmd_obj_sp);
         AddAlias ("run", cmd_obj_sp);
         AddOrReplaceAliasOptions ("r", alias_arguments_vector_sp);
         AddOrReplaceAliasOptions ("run", alias_arguments_vector_sp);

source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp

 #include "Plugins/Process/Utility/RegisterContextDarwin_arm64.h"
 #include "Plugins/Process/Utility/RegisterContextDarwin_i386.h"
 #include "Plugins/Process/Utility/RegisterContextDarwin_x86_64.h"
 
 #include "lldb/Utility/SafeMachO.h"
 
 #include "ObjectFileMachO.h"
 
-#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__))
+#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
 // GetLLDBSharedCacheUUID() needs to call dlsym()
 #include <dlfcn.h>
 #endif
 
 #ifndef __APPLE__
 #include "Utility/UuidCompatibility.h"
 #endif
 
if (symtab_load_command.cmd)
             {
                 const addr_t linkedit_load_addr = linkedit_section_sp->GetLoadBaseAddress(&target);
                 const addr_t linkedit_file_offset = linkedit_section_sp->GetFileOffset();
                 const addr_t symoff_addr = linkedit_load_addr + symtab_load_command.symoff - linkedit_file_offset;
                 strtab_addr = linkedit_load_addr + symtab_load_command.stroff - linkedit_file_offset;
 
                 bool data_was_read = false;
 
-#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__))
+#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
                 if (m_header.flags & 0x80000000u && process->GetAddressByteSize() == sizeof (void*))
                 {
                     // This mach-o memory file is in the dyld shared cache. If this
                     // program is not remote and this is iOS, then this process will
                     // share the same shared cache as the process we are debugging and
                     // we can read the entire __LINKEDIT from the address space in this
                     // process. This is a needed optimization that is used for local iOS
                     // debugging only since all shared libraries in the shared cache do
#endif
                 if (text_segment_file_addr != LLDB_INVALID_ADDRESS)
                 {
                     for (auto &e : trie_entries)
                         e.entry.address += text_segment_file_addr;
                 }
             }
         }
 
-#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__))
+#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
 
         // Some recent builds of the dyld_shared_cache (hereafter: DSC) have been optimized by moving LOCAL
         // symbols out of the memory mapped portion of the DSC. The symbol information has all been retained,
         // but it isn't available in the normal nlist data. However, there *are* duplicate entries of *some*
         // LOCAL symbols in the normal nlist data. To handle this situation correctly, we must first attempt
         // to parse any DSC unmapped symbol information. If we find any, we set a flag that tells the normal
         // nlist parser to ignore all LOCAL symbols.
 
ObjectFileMachO::GetProcessSharedCacheUUID (Process *process)
     }
     return uuid;
 }
 
 UUID
 ObjectFileMachO::GetLLDBSharedCacheUUID ()
 {
     UUID uuid;
-#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__))
+#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
     uint8_t *(*dyld_get_all_image_infos)(void);
     dyld_get_all_image_infos = (uint8_t*(*)()) dlsym (RTLD_DEFAULT, "_dyld_get_all_image_infos");
     if (dyld_get_all_image_infos)
     {
         uint8_t *dyld_all_image_infos_address = dyld_get_all_image_infos();
         if (dyld_all_image_infos_address)
         {
             uint32_t *version = (uint32_t*) dyld_all_image_infos_address;              // version <mach-o/dyld_images.h>

source/Plugins/Platform/MacOSX/PlatformDarwinKernel.cpp

if (exe_file.Exists())
         exe_module_sp.reset();
     }
     return error;
 }
 
 bool
 PlatformDarwinKernel::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch)
 {
-#if defined (__arm__) || defined (__arm64__)
+#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
     return ARMGetSupportedArchitectureAtIndex (idx, arch);
 #else
     return x86GetSupportedArchitectureAtIndex (idx, arch);
 #endif
 }
 
 void
 PlatformDarwinKernel::CalculateTrapHandlerSymbolNames ()

source/Plugins/Platform/MacOSX/PlatformMacOSX.cpp

PlatformMacOSX::GetFileWithUUID (const lldb_private::FileSpec &platform_file,
     }
     local_file = platform_file;
     return Error();
 }
 
 bool
 PlatformMacOSX::GetSupportedArchitectureAtIndex (uint32_t idx, ArchSpec &arch)
 {
-#if defined (__arm__) || defined (__arm64__)
+#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
     return ARMGetSupportedArchitectureAtIndex (idx, arch);
 #else
     return x86GetSupportedArchitectureAtIndex (idx, arch);
 #endif
 }
 
 lldb_private::Error
 PlatformMacOSX::GetSharedModule (const lldb_private::ModuleSpec &module_spec,

source/Plugins/Process/Utility/RegisterContextDarwin_arm64.cpp

RegisterContextDarwin_arm64::ConvertRegisterKindToRegisterNumber (RegisterKind kind, uint32_t reg)
     }
     return LLDB_INVALID_REGNUM;
 }
 
 
 uint32_t
 RegisterContextDarwin_arm64::NumSupportedHardwareWatchpoints ()
 {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
     // autodetect how many watchpoints are supported dynamically...
     static uint32_t g_num_supported_hw_watchpoints = UINT32_MAX;
     if (g_num_supported_hw_watchpoints == UINT32_MAX)
     {
         size_t len;
         uint32_t n = 0;
         len = sizeof (n);
         if (::sysctlbyname("hw.optional.watchpoint", &n, &len, NULL, 0) == 0)

source/Plugins/Process/Utility/RegisterContextMacOSXFrameBackchain.cpp

case eEncodingIEEE754:
             {
                 value.SetUInt64(reg_value, RegisterValue::eTypeDouble);
                 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(_MSC_VER) && !defined(__mips__)
+#if !defined(__arm__) && !defined(__arm64__) && !defined(__aarch64__) && !defined(_MSC_VER) && !defined(__mips__)
         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))
             {

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

#endif
     if (Host::GetOSKernelDescription (s))
     {
         response.PutCString ("os_kernel:");
         response.PutCStringAsRawHex8(s.c_str());
         response.PutChar(';');
     }
 #if defined(__APPLE__)
 
-#if defined(__arm__) || defined(__arm64__)
+#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
     // For iOS devices, we are connected through a USB Mux so we never pretend
     // to actually have a hostname as far as the remote lldb that is connecting
     // to this lldb-platform is concerned
     response.PutCString ("hostname:");
     response.PutCStringAsRawHex8("127.0.0.1");
     response.PutChar(';');
-#else   // #if defined(__arm__) || defined(__arm64__)
+#else   // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
     if (Host::GetHostname (s))
     {
         response.PutCString ("hostname:");
         response.PutCStringAsRawHex8(s.c_str());
         response.PutChar(';');
     }
-#endif  // #if defined(__arm__) || defined(__arm64__)
+#endif  // #if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
 
 #else   // #if defined(__APPLE__)
     if (Host::GetHostname (s))
     {
         response.PutCString ("hostname:");
         response.PutCStringAsRawHex8(s.c_str());
         response.PutChar(';');
     }

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

 #if defined (__APPLE__)
 #define LOW_PORT    (IPPORT_RESERVED)
 #define HIGH_PORT   (IPPORT_HIFIRSTAUTO)
 #else
 #define LOW_PORT    (1024u)
 #define HIGH_PORT   (49151u)
 #endif
 
-#if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__))
+#if defined(__APPLE__) && (defined(__arm__) || defined(__arm64__) || defined(__aarch64__))
 static bool rand_initialized = false;
 
 static inline uint16_t
 get_random_port ()
 {
     if (!rand_initialized)
     {
         time_t seed = time(NULL);
ProcessGDBRemote::LaunchAndConnectToDebugserver (const ProcessInfo &process_info)
     {
         // If we locate debugserver, keep that located version around
         static FileSpec g_debugserver_file_spec;
 
         ProcessLaunchInfo debugserver_launch_info;
         debugserver_launch_info.SetMonitorProcessCallback (MonitorDebugserverProcess, this, false);
         debugserver_launch_info.SetUserID(process_info.GetUserID());
 
-#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__))
+#if defined (__APPLE__) && (defined (__arm__) || defined (__arm64__) || defined (__aarch64__))
         // On iOS, still do a local connection using a random port
         const char *hostname = "127.0.0.1";
         uint16_t port = get_random_port ();
 #else
         // Set hostname being NULL to do the reverse connect where debugserver
         // will bind to port zero and it will communicate back to us the port
         // that we will connect to
         const char *hostname = NULL;

test/functionalities/data-formatter/data-formatter-objc/main.m

 //===-- main.m ------------------------------------------------*- ObjC -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #import <Foundation/Foundation.h>
 
 #if defined(__APPLE__)
-#if defined(__arm__) || defined(__arm64__)
+#if defined(__arm__) || defined(__arm64__) || defined(__aarch64__)
 #define IOS
 #endif
 #endif
 
 #if defined(IOS)
 #import <Foundation/NSGeometry.h>
 #else
 #import <Carbon/Carbon.h>

tools/debugserver/source/DNB.cpp

 
 void
 DNBInitialize()
 {
     DNBLogThreadedIf (LOG_PROCESS, "DNBInitialize ()");
 #if defined (__i386__) || defined (__x86_64__)
     DNBArchImplI386::Initialize();
     DNBArchImplX86_64::Initialize();
-#elif defined (__arm__) || defined (__arm64__)
+#elif defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
     DNBArchMachARM::Initialize();
     DNBArchMachARM64::Initialize();
 #endif
 }
 
 void
 DNBTerminate()
 {
 }
 
 nub_bool_t
 DNBSetArchitecture (const char *arch)
 {
     if (arch && arch[0])
     {
         if (strcasecmp (arch, "i386") == 0)
             return DNBArchProtocol::SetArchitecture (CPU_TYPE_I386);
         else if ((strcasecmp (arch, "x86_64") == 0) || (strcasecmp (arch, "x86_64h") == 0))
             return DNBArchProtocol::SetArchitecture (CPU_TYPE_X86_64);
-        else if (strstr (arch, "arm64") == arch || strstr (arch, "armv8") == arch)
+        else if (strstr (arch, "arm64") == arch || strstr (arch, "armv8") == arch || strstr (arch, "aarch64") == arch)
             return DNBArchProtocol::SetArchitecture (CPU_TYPE_ARM64);
         else if (strstr (arch, "arm") == arch)
             return DNBArchProtocol::SetArchitecture (CPU_TYPE_ARM);
     }
     return false;
 }

tools/debugserver/source/DNBDefs.h

 #include <signal.h>
 #include <stdio.h>
 #include <sys/syslimits.h>
 #include <unistd.h>
 
 //----------------------------------------------------------------------
 // Define nub_addr_t and the invalid address value from the architecture
 //----------------------------------------------------------------------
-#if defined (__x86_64__) || defined (__ppc64__) || defined (__arm64__)
+#if defined (__x86_64__) || defined (__ppc64__) || defined (__arm64__) || defined (__aarch64__)
 
 //----------------------------------------------------------------------
 // 64 bit address architectures
 //----------------------------------------------------------------------
 typedef uint64_t        nub_addr_t;
 #define INVALID_NUB_ADDRESS     ((nub_addr_t)~0ull)
 
 #elif defined (__i386__) || defined (__powerpc__) || defined (__ppc__) || defined (__arm__)

tools/debugserver/source/MacOSX/MachThreadList.cpp

if (process->StopCount() == 0)
             if (processInfo.kp_proc.p_flag & P_LP64)
                 m_is_64_bit = true;
         }
 #if defined (__i386__) || defined (__x86_64__)
         if (m_is_64_bit)
             DNBArchProtocol::SetArchitecture(CPU_TYPE_X86_64);
         else
             DNBArchProtocol::SetArchitecture(CPU_TYPE_I386);
-#elif defined (__arm__) || defined (__arm64__)
+#elif defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
         if (m_is_64_bit)
             DNBArchProtocol::SetArchitecture(CPU_TYPE_ARM64);
         else
             DNBArchProtocol::SetArchitecture(CPU_TYPE_ARM);
 #endif
     }
     
     if (m_threads.empty() || update)

tools/debugserver/source/MacOSX/arm/DNBArchImpl.h

 //===-- DNBArchImpl.h -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  Created by Greg Clayton on 6/25/07.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef __DebugNubArchMachARM_h__
 #define __DebugNubArchMachARM_h__
 
-#if defined (__arm__) || defined (__arm64__)
+#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
 
 #include "DNBArch.h"
 
 #include <map>
 
 class MachThread;
 
 class DNBArchMachARM : public DNBArchProtocol
#endif
     virtual bool            DisableHardwareWatchpoint (uint32_t hw_break_index, bool also_set_on_task);
     virtual bool            DisableHardwareWatchpoint_helper (uint32_t hw_break_index, bool also_set_on_task);
     virtual bool            ReenableHardwareWatchpoint (uint32_t hw_break_index);
     virtual bool            ReenableHardwareWatchpoint_helper (uint32_t hw_break_index);
 
     virtual bool            StepNotComplete ();
     virtual uint32_t        GetHardwareWatchpointHit(nub_addr_t &addr);
 
-#if defined (ARM_DEBUG_STATE32) && defined (__arm64__)
+#if defined (ARM_DEBUG_STATE32) && (defined (__arm64__) || defined (__aarch64__))
     typedef arm_debug_state32_t DBG;
 #else
     typedef arm_debug_state_t DBG;
 #endif
 
 protected:
 
 
#endif
     void                    EvaluateNextInstructionForSoftwareBreakpointSetup(nub_addr_t currentPC, uint32_t cpsr, bool currentPCIsThumb, nub_addr_t *nextPC, bool *nextPCIsThumb);
 
     typedef enum RegisterSetTag
     {
         e_regSetALL = REGISTER_SET_ALL,
         e_regSetGPR = ARM_THREAD_STATE,
         e_regSetVFP = ARM_VFP_STATE,
         e_regSetEXC = ARM_EXCEPTION_STATE,
-#if defined (ARM_DEBUG_STATE32) && defined (__arm64__)
+#if defined (ARM_DEBUG_STATE32) && (defined (__arm64__) || defined (__aarch64__))
         e_regSetDBG = ARM_DEBUG_STATE32,
 #else
         e_regSetDBG = ARM_DEBUG_STATE,
 #endif
         kNumRegisterSets
     } RegisterSet;
 
     enum

tools/debugserver/source/MacOSX/arm/DNBArchImpl.cpp

 //===-- DNBArchImpl.cpp -----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  Created by Greg Clayton on 6/25/07.
 //
 //===----------------------------------------------------------------------===//
 
-#if defined (__arm__) || defined (__arm64__)
+#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
 
 #include "MacOSX/arm/DNBArchImpl.h"
 #include "MacOSX/MachProcess.h"
 #include "MacOSX/MachThread.h"
 #include "DNBBreakpoint.h"
 #include "DNBLog.h"
 #include "DNBRegisterInfo.h"
 #include "DNB.h"

 {
     int set = e_regSetDBG;
 
     // Check if we have valid cached registers
     if (!force && m_state.GetError(set, Read) == KERN_SUCCESS)
         return KERN_SUCCESS;
 
     // Read the registers from our thread
-#if defined (ARM_DEBUG_STATE32) && defined (__arm64__)
+#if defined (ARM_DEBUG_STATE32) && (defined (__arm64__) || defined (__aarch64__))
     mach_msg_type_number_t count = ARM_DEBUG_STATE32_COUNT;
     kern_return_t kret = ::thread_get_state(m_thread->MachPortNumber(), ARM_DEBUG_STATE32, (thread_state_t)&m_state.dbg, &count);
 #else
     mach_msg_type_number_t count = ARM_DEBUG_STATE_COUNT;
     kern_return_t kret = ::thread_get_state(m_thread->MachPortNumber(), ARM_DEBUG_STATE, (thread_state_t)&m_state.dbg, &count);
 #endif
     m_state.SetError(set, Read, kret);
 
DNBArchMachARM::SetEXCState()
     m_state.InvalidateRegisterSetState(set);    // Invalidate the current register state in case registers are read back differently
     return kret;                                // Return the error code
 }
 
 kern_return_t
 DNBArchMachARM::SetDBGState(bool also_set_on_task)
 {
     int set = e_regSetDBG;
-#if defined (ARM_DEBUG_STATE32) && defined (__arm64__)
+#if defined (ARM_DEBUG_STATE32) && (defined (__arm64__) || defined (__aarch64__))
     kern_return_t kret = ::thread_set_state (m_thread->MachPortNumber(), ARM_DEBUG_STATE32, (thread_state_t)&m_state.dbg, ARM_DEBUG_STATE32_COUNT);
     if (also_set_on_task)
     {
         kern_return_t task_kret = ::task_set_state (m_thread->Process()->Task().TaskPort(), ARM_DEBUG_STATE32, (thread_state_t)&m_state.dbg, ARM_DEBUG_STATE32_COUNT);
         if (task_kret != KERN_SUCCESS)
              DNBLogThreadedIf(LOG_WATCHPOINTS, "DNBArchMachARM::SetDBGState failed to set debug control register state: 0x%8.8x.", kret);
     }
 #else
if (err.Fail())
         err.LogThreaded("%s: failed to read the DBG registers", __FUNCTION__);
         return err.Error();
     }
 
 // The use of __arm64__ here is not ideal.  If debugserver is running on
 // an armv8 device, regardless of whether it was built for arch arm or arch arm64,
 // it needs to use the MDSCR_EL1 SS bit to single instruction step.
 
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
     if (enable)
     {
         DNBLogThreadedIf(LOG_STEP, "%s: Setting MDSCR_EL1 Single Step bit at pc 0x%llx", __FUNCTION__, (uint64_t) m_state.context.gpr.__pc);
         m_state.dbg.__mdscr_el1 |= 1;  // Set bit 0 (single step, SS) in the MDSCR_EL1.
     }
     else
     {
         DNBLogThreadedIf(LOG_STEP, "%s: Clearing MDSCR_EL1 Single Step bit at pc 0x%llx", __FUNCTION__, (uint64_t) m_state.context.gpr.__pc);
if (g_num_supported_hw_breakpoints == UINT_MAX)
         len = sizeof (n);
         if (::sysctlbyname("hw.optional.breakpoint", &n, &len, NULL, 0) == 0)
         {
             g_num_supported_hw_breakpoints = n;
             DNBLogThreadedIf(LOG_THREAD, "hw.optional.breakpoint=%u", n);
         }
         else
         {
-#if !defined (__arm64__)
+#if !defined (__arm64__) && !defined (__aarch64__)
             // Read the DBGDIDR to get the number of available hardware breakpoints
             // However, in some of our current armv7 processors, hardware
             // breakpoints/watchpoints were not properly connected. So detect those
             // cases using a field in a sysctl. For now we are using "hw.cpusubtype"
             // field to distinguish CPU architectures. This is a hack until we can
             // get <rdar://problem/6372672> fixed, at which point we will switch to
             // using a different sysctl string that will tell us how many BRPs
             // are available to us directly without having to read DBGDIDR.
if (g_num_supported_hw_watchpoints == UINT_MAX)
         len = sizeof (n);
         if (::sysctlbyname("hw.optional.watchpoint", &n, &len, NULL, 0) == 0)
         {
             g_num_supported_hw_watchpoints = n;
             DNBLogThreadedIf(LOG_THREAD, "hw.optional.watchpoint=%u", n);
         }
         else
         {
-#if !defined (__arm64__)
+#if !defined (__arm64__) && !defined (__aarch64__)
             // Read the DBGDIDR to get the number of available hardware breakpoints
             // However, in some of our current armv7 processors, hardware
             // breakpoints/watchpoints were not properly connected. So detect those
             // cases using a field in a sysctl. For now we are using "hw.cpusubtype"
             // field to distinguish CPU architectures. This is a hack until we can
             // get <rdar://problem/6372672> fixed, at which point we will switch to
             // using a different sysctl string that will tell us how many WRPs
             // are available to us directly without having to read DBGDIDR.
DNBArchMachARM::DisableHardwareBreakpoint (uint32_t hw_index)
     return false;
 }
 
 // ARM v7 watchpoints may be either word-size or double-word-size.
 // It's implementation defined which they can handle.  It looks like on an
 // armv8 device, armv7 processes can watch dwords.  But on a genuine armv7
 // device I tried, only word watchpoints are supported.
 
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
 #define WATCHPOINTS_ARE_DWORD 1
 #else
 #undef WATCHPOINTS_ARE_DWORD
 #endif
 
 uint32_t
 DNBArchMachARM::EnableHardwareWatchpoint (nub_addr_t addr, nub_size_t size, bool read, bool write, bool also_set_on_task)
 {

tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.h

 //===-- DNBArchMachARM64.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 
 #ifndef __DNBArchImplARM64_h__
 #define __DNBArchImplARM64_h__
 
-#if defined (__arm__) || defined (__arm64__)
+#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
 
 #include <map>
 #include <mach/thread_status.h>
 
 #if defined (ARM_THREAD_STATE64_COUNT)
 
 #include "DNBArch.h"
 

tools/debugserver/source/MacOSX/arm64/DNBArchImplARM64.cpp

 //===-- DNBArchMachARM64.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  Created by Greg Clayton on 6/25/07.
 //
 //===----------------------------------------------------------------------===//
 
-#if defined (__arm__) || defined (__arm64__)
+#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
 
 #include "MacOSX/arm64/DNBArchImplARM64.h"
 
 #if defined (ARM_THREAD_STATE64_COUNT)
 
 #include "MacOSX/MachProcess.h"
 #include "MacOSX/MachThread.h"
 #include "DNBBreakpoint.h"
DNBArchMachARM64::GetVFPState(bool force)
     if (!force && m_state.GetError(set, Read) == KERN_SUCCESS)
         return KERN_SUCCESS;
 
     // Read the registers from our thread
     mach_msg_type_number_t count = e_regSetVFPCount;
     kern_return_t kret = ::thread_get_state(m_thread->MachPortNumber(), ARM_NEON_STATE64, (thread_state_t)&m_state.context.vfp, &count);
     if (DNBLogEnabledForAny (LOG_THREAD))
     {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
         DNBLogThreaded("thread_get_state(0x%4.4x, %u, &vfp, %u) => 0x%8.8x (count = %u) regs"
                        "\n   q0  = 0x%16.16llx%16.16llx"
                        "\n   q1  = 0x%16.16llx%16.16llx"
                        "\n   q2  = 0x%16.16llx%16.16llx"
                        "\n   q3  = 0x%16.16llx%16.16llx"
                        "\n   q4  = 0x%16.16llx%16.16llx"
                        "\n   q5  = 0x%16.16llx%16.16llx"
                        "\n   q6  = 0x%16.16llx%16.16llx"

 const char *g_invalidate_v25[] {"v25", "d25", "s25", NULL };
 const char *g_invalidate_v26[] {"v26", "d26", "s26", NULL };
 const char *g_invalidate_v27[] {"v27", "d27", "s27", NULL };
 const char *g_invalidate_v28[] {"v28", "d28", "s28", NULL };
 const char *g_invalidate_v29[] {"v29", "d29", "s29", NULL };
 const char *g_invalidate_v30[] {"v30", "d30", "s30", NULL };
 const char *g_invalidate_v31[] {"v31", "d31", "s31", NULL };
 
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
 #define VFP_V_OFFSET_IDX(idx) (offsetof (DNBArchMachARM64::FPU, __v) + (idx * 16) + offsetof (DNBArchMachARM64::Context, vfp))
 #else
 #define VFP_V_OFFSET_IDX(idx) (offsetof (DNBArchMachARM64::FPU, opaque) + (idx * 16) + offsetof (DNBArchMachARM64::Context, vfp))
 #endif
 #define VFP_OFFSET_NAME(reg) (offsetof (DNBArchMachARM64::FPU, reg) + offsetof (DNBArchMachARM64::Context, vfp))
 #define EXC_OFFSET(reg)      (offsetof (DNBArchMachARM64::EXC, reg)  + offsetof (DNBArchMachARM64::Context, exc))
 
 //#define FLOAT_FORMAT Float
if (regInfo)
                 return true;
             }
             break;
 
         case e_regSetVFP:
 
             if (reg >= vfp_v0 && reg <= vfp_v31)
             {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
                 memcpy (&value->value.v_uint8, &m_state.context.vfp.__v[reg - vfp_v0], 16);
 #else
                 memcpy (&value->value.v_uint8, ((uint8_t *) &m_state.context.vfp.opaque) + ((reg - vfp_v0) * 16), 16);
 #endif
                 return true;
             }
             else if (reg == vfp_fpsr)
             {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
                 memcpy (&value->value.uint32, &m_state.context.vfp.__fpsr, 4);
 #else
                 memcpy (&value->value.uint32, ((uint8_t *) &m_state.context.vfp.opaque) + (32 * 16) + 0, 4);
 #endif
                 return true;
             }
             else if (reg == vfp_fpcr)
             {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
                 memcpy (&value->value.uint32, &m_state.context.vfp.__fpcr, 4);
 #else
                 memcpy (&value->value.uint32, ((uint8_t *) &m_state.context.vfp.opaque) + (32 * 16) + 4, 4);
 #endif
                 return true;
             }
             else if (reg >= vfp_s0 && reg <= vfp_s31)
             {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
                 memcpy (&value->value.v_uint8, &m_state.context.vfp.__v[reg - vfp_s0], 4);
 #else
                 memcpy (&value->value.v_uint8, ((uint8_t *) &m_state.context.vfp.opaque) + ((reg - vfp_s0) * 16), 4);
 #endif
                 return true;
             }
             else if (reg >= vfp_d0 && reg <= vfp_d31)
             {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
                 memcpy (&value->value.v_uint8, &m_state.context.vfp.__v[reg - vfp_d0], 8);
 #else
                 memcpy (&value->value.v_uint8, ((uint8_t *) &m_state.context.vfp.opaque) + ((reg - vfp_d0) * 16), 8);
 #endif
                 return true;
             }
             break;
 
if (regInfo)
                 m_state.context.gpr.__cpsr = value->value.uint32;
                 success = true;
             }
             break;
             
         case e_regSetVFP:
             if (reg >= vfp_v0 && reg <= vfp_v31)
             {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
                 memcpy (&m_state.context.vfp.__v[reg - vfp_v0], &value->value.v_uint8, 16);
 #else
                 memcpy (((uint8_t *) &m_state.context.vfp.opaque) + ((reg - vfp_v0) * 16), &value->value.v_uint8, 16);
 #endif
                 success = true;
             }
             else if (reg == vfp_fpsr)
             {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
                 memcpy (&m_state.context.vfp.__fpsr, &value->value.uint32, 4);
 #else
                 memcpy (((uint8_t *) &m_state.context.vfp.opaque) + (32 * 16) + 0, &value->value.uint32, 4);
 #endif
                 success = true;
             }
             else if (reg == vfp_fpcr)
             {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
                 memcpy (&m_state.context.vfp.__fpcr, &value->value.uint32, 4);
 #else
                 memcpy (((uint8_t *) m_state.context.vfp.opaque) + (32 * 16) + 4, &value->value.uint32, 4);
 #endif
                 success = true;
             }
             else if (reg >= vfp_s0 && reg <= vfp_s31)
             {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
                 memcpy (&m_state.context.vfp.__v[reg - vfp_s0], &value->value.v_uint8, 4);
 #else
                 memcpy (((uint8_t *) &m_state.context.vfp.opaque) + ((reg - vfp_s0) * 16), &value->value.v_uint8, 4);
 #endif
                 success = true;
             }
             else if (reg >= vfp_d0 && reg <= vfp_d31)
             {
-#if defined (__arm64__)
+#if defined (__arm64__) || defined (__aarch64__)
                 memcpy (&m_state.context.vfp.__v[reg - vfp_d0], &value->value.v_uint8, 8);
 #else
                 memcpy (((uint8_t *) &m_state.context.vfp.opaque) + ((reg - vfp_d0) * 16), &value->value.v_uint8, 8);
 #endif
                 success = true;
             }
             break;
             
if (pos != m_saved_register_states.end())
         m_saved_register_states.erase(pos);
         return success;
     }
     return false;
 }
 
 
 #endif  // #if defined (ARM_THREAD_STATE64_COUNT)
-#endif  // #if defined (__arm__)
+#endif  // #if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)

tools/debugserver/source/RNBDefs.h

 #elif defined (__ppc64__)
 
 #define RNB_ARCH    "ppc64"
 
 #elif defined (__powerpc__) || defined (__ppc__)
 
 #define RNB_ARCH    "ppc"
 
-#elif defined (__arm64__)
+#elif defined (__arm64__) || defined (__aarch64__)
 
 #define RNB_ARCH    "arm64"
 
 #elif defined (__arm__)
 
 #define RNB_ARCH    "armv7"
 
 #else

tools/debugserver/source/RNBRemote.cpp

 // If we fail to get back a valid CPU type for the remote process,
 // make a best guess for the CPU type based on the currently running
 // debugserver binary -- the debugger may not handle the case of an
 // un-specified process CPU type correctly.
 
 static cpu_type_t
 best_guess_cpu_type ()
 {
-#if defined (__arm__) || defined (__arm64__)
+#if defined (__arm__) || defined (__arm64__) || defined (__aarch64__)
     if (sizeof (char *) == 8)
     {
         return CPU_TYPE_ARM64;
     }   
     else
     {
         return CPU_TYPE_ARM;
     }   
#if (defined (__x86_64__) || defined (__i386__)) && defined (x86_THREAD_STATE)
     {
         if (gp_regs.tsh.flavor == x86_THREAD_STATE64)
             rep << "ptrsize:8;";
         else
             rep << "ptrsize:4;";
     }
 #elif defined (__arm__)
     rep << "ptrsize:4;";
-#elif defined (__arm64__) && defined (ARM_UNIFIED_THREAD_STATE)
+#elif (defined (__arm64__) || defined (__aarch64__)) && defined (ARM_UNIFIED_THREAD_STATE)
     nub_thread_t thread = DNBProcessGetCurrentThreadMachPort (pid);
     kern_return_t kr;
     arm_unified_thread_state_t gp_regs;
     mach_msg_type_number_t gp_count = ARM_UNIFIED_THREAD_STATE_COUNT;
     kr = thread_get_state (thread, ARM_UNIFIED_THREAD_STATE,
                            (thread_state_t) &gp_regs, &gp_count);
     if (kr == KERN_SUCCESS)
     {