1 files changed, 74 insertions, 182 deletions

diff --git a/src/common/mac/arch_utilities.cc b/src/common/mac/arch_utilities.cc
index 392efe78..96340d54 100644
--- a/src/common/mac/arch_utilities.cc
+++ b/src/common/mac/arch_utilities.cc
@@ -26,113 +26,22 @@
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>  // Must come first
+#endif
+
 #include "common/mac/arch_utilities.h"
 
+#include <mach/machine.h>
 #include <mach-o/arch.h>
 #include <mach-o/fat.h>
 #include <stdio.h>
 #include <string.h>
 
-#ifndef CPU_SUBTYPE_ARM_V7S
-#define CPU_SUBTYPE_ARM_V7S (static_cast<cpu_subtype_t>(11))
-#endif  // CPU_SUBTYPE_ARM_V7S
-
-#ifndef CPU_TYPE_ARM64
-#define CPU_TYPE_ARM64 (CPU_TYPE_ARM | CPU_ARCH_ABI64)
-#endif  // CPU_TYPE_ARM64
-
-#ifndef CPU_SUBTYPE_ARM64_ALL
-#define CPU_SUBTYPE_ARM64_ALL (static_cast<cpu_subtype_t>(0))
-#endif  // CPU_SUBTYPE_ARM64_ALL
-
-#ifndef CPU_SUBTYPE_ARM64_E
-#define CPU_SUBTYPE_ARM64_E (static_cast<cpu_subtype_t>(2))
-#endif  // CPU_SUBTYPE_ARM64_E
-
-namespace {
-
-const NXArchInfo* ArchInfo_arm64(cpu_subtype_t cpu_subtype) {
-  const char* name = NULL;
-  switch (cpu_subtype) {
-    case CPU_SUBTYPE_ARM64_ALL:
-      name = "arm64";
-      break;
-    case CPU_SUBTYPE_ARM64_E:
-      name = "arm64e";
-      break;
-    default:
-      return NULL;
-  }
-
-  NXArchInfo* arm64 = new NXArchInfo;
-  *arm64 = *NXGetArchInfoFromCpuType(CPU_TYPE_ARM,
-                                     CPU_SUBTYPE_ARM_V7);
-  arm64->name = name;
-  arm64->cputype = CPU_TYPE_ARM64;
-  arm64->cpusubtype = cpu_subtype;
-  arm64->description = "arm 64";
-  return arm64;
-}
-
-const NXArchInfo* ArchInfo_armv7s() {
-  NXArchInfo* armv7s = new NXArchInfo;
-  *armv7s = *NXGetArchInfoFromCpuType(CPU_TYPE_ARM,
-                                      CPU_SUBTYPE_ARM_V7);
-  armv7s->name = "armv7s";
-  armv7s->cpusubtype = CPU_SUBTYPE_ARM_V7S;
-  armv7s->description = "arm v7s";
-  return armv7s;
-}
-
-}  // namespace
-
-namespace google_breakpad {
-
-const NXArchInfo* BreakpadGetArchInfoFromName(const char* arch_name) {
-  // TODO: Remove this when the OS knows about arm64.
-  if (!strcmp("arm64", arch_name))
-    return BreakpadGetArchInfoFromCpuType(CPU_TYPE_ARM64,
-                                          CPU_SUBTYPE_ARM64_ALL);
-
-  if (!strcmp("arm64e", arch_name))
-    return BreakpadGetArchInfoFromCpuType(CPU_TYPE_ARM64,
-                                          CPU_SUBTYPE_ARM64_E);
-
-  // TODO: Remove this when the OS knows about armv7s.
-  if (!strcmp("armv7s", arch_name))
-    return BreakpadGetArchInfoFromCpuType(CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7S);
-
-  return NXGetArchInfoFromName(arch_name);
-}
-
-const NXArchInfo* BreakpadGetArchInfoFromCpuType(cpu_type_t cpu_type,
-                                                 cpu_subtype_t cpu_subtype) {
-  // TODO: Remove this when the OS knows about arm64.
-  if (cpu_type == CPU_TYPE_ARM64 && cpu_subtype == CPU_SUBTYPE_ARM64_ALL) {
-    static const NXArchInfo* arm64 = ArchInfo_arm64(cpu_subtype);
-    return arm64;
-  }
-
-  if (cpu_type == CPU_TYPE_ARM64 && cpu_subtype == CPU_SUBTYPE_ARM64_E) {
-    static const NXArchInfo* arm64e = ArchInfo_arm64(cpu_subtype);
-    return arm64e;
-  }
-
-  // TODO: Remove this when the OS knows about armv7s.
-  if (cpu_type == CPU_TYPE_ARM && cpu_subtype == CPU_SUBTYPE_ARM_V7S) {
-    static const NXArchInfo* armv7s = ArchInfo_armv7s();
-    return armv7s;
-  }
-
-  return NXGetArchInfoFromCpuType(cpu_type, cpu_subtype);
-}
-
-}  // namespace google_breakpad
+#ifdef __APPLE__
+#include <mach-o/utils.h>
+#endif
 
-// TODO(crbug.com/1242776): The "#ifndef __APPLE__" should be here, but the
-// system version of NXGetLocalArchInfo returns incorrect information on
-// x86_64 machines (treating them as just x86), so use the Breakpad version
-// all the time for now.
 namespace {
 
 enum Architecture {
@@ -147,69 +56,31 @@ enum Architecture {
   kNumArchitectures
 };
 
+struct NamedArchInfo {
+  const char* name;
+  ArchInfo info;
+};
+
 // enum Architecture above and kKnownArchitectures below
 // must be kept in sync.
-const NXArchInfo kKnownArchitectures[] = {
-  {
-    "i386",
-    CPU_TYPE_I386,
-    CPU_SUBTYPE_I386_ALL,
-    NX_LittleEndian,
-    "Intel 80x86"
-  },
-  {
-    "x86_64",
-    CPU_TYPE_X86_64,
-    CPU_SUBTYPE_X86_64_ALL,
-    NX_LittleEndian,
-    "Intel x86-64"
-  },
-  {
-    "x86_64h",
-    CPU_TYPE_X86_64,
-    CPU_SUBTYPE_X86_64_H,
-    NX_LittleEndian,
-    "Intel x86-64h Haswell"
-  },
-  {
-    "arm",
-    CPU_TYPE_ARM,
-    CPU_SUBTYPE_ARM_ALL,
-    NX_LittleEndian,
-    "ARM"
-  },
-  {
-    "arm64",
-    CPU_TYPE_ARM64,
-    CPU_SUBTYPE_ARM64_ALL,
-    NX_LittleEndian,
-    "ARM64"
-  },
-  {
-    "arm64e",
-    CPU_TYPE_ARM64,
-    CPU_SUBTYPE_ARM64_E,
-    NX_LittleEndian,
-    "ARM64e"
-  },
-  {
-    "ppc",
-    CPU_TYPE_POWERPC,
-    CPU_SUBTYPE_POWERPC_ALL,
-    NX_BigEndian,
-    "PowerPC"
-  }
-};
+constexpr NamedArchInfo kKnownArchitectures[] = {
+    {"i386", {CPU_TYPE_I386, CPU_SUBTYPE_I386_ALL}},
+    {"x86_64", {CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_ALL}},
+    {"x86_64h", {CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_H}},
+    {"arm", {CPU_TYPE_ARM, CPU_SUBTYPE_ARM_ALL}},
+    {"arm64", {CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_ALL}},
+    {"arm64e", {CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64E}},
+    {"ppc", {CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_ALL}}};
 
 }  // namespace
 
-const NXArchInfo *NXGetLocalArchInfo(void) {
+ArchInfo GetLocalArchInfo(void) {
   Architecture arch;
 #if defined(__i386__)
   arch = kArch_i386;
 #elif defined(__x86_64__)
   arch = kArch_x86_64;
-#elif defined(__arm64)
+#elif defined(__arm64__) || defined(__aarch64__)
   arch = kArch_arm64;
 #elif defined(__arm__)
   arch = kArch_arm;
@@ -218,51 +89,72 @@ const NXArchInfo *NXGetLocalArchInfo(void) {
 #else
   #error "Unsupported CPU architecture"
 #endif
-  return &kKnownArchitectures[arch];
+  return kKnownArchitectures[arch].info;
 }
 
-#ifndef __APPLE__
+#ifdef __APPLE__
 
-const NXArchInfo *NXGetArchInfoFromName(const char *name) {
-  for (int arch = 0; arch < kNumArchitectures; ++arch) {
-    if (!strcmp(name, kKnownArchitectures[arch].name)) {
-      return &kKnownArchitectures[arch];
+std::optional<ArchInfo> GetArchInfoFromName(const char* arch_name) {
+  if (__builtin_available(macOS 13.0, iOS 16.0, *)) {
+    cpu_type_t type;
+    cpu_subtype_t subtype;
+    if (macho_cpu_type_for_arch_name(arch_name, &type, &subtype)) {
+      return ArchInfo{type, subtype};
+    }
+  } else {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    const NXArchInfo* info = NXGetArchInfoFromName(arch_name);
+#pragma clang diagnostic pop
+    if (info) {
+      return ArchInfo{info->cputype, info->cpusubtype};
     }
   }
-  return NULL;
+  return std::nullopt;
 }
 
-const NXArchInfo *NXGetArchInfoFromCpuType(cpu_type_t cputype,
-                                           cpu_subtype_t cpusubtype) {
-  const NXArchInfo *candidate = NULL;
+const char* GetNameFromCPUType(cpu_type_t cpu_type, cpu_subtype_t cpu_subtype) {
+  if (__builtin_available(macOS 13.0, iOS 16.0, *)) {
+    const char* name = macho_arch_name_for_cpu_type(cpu_type, cpu_subtype);
+    if (name) {
+      return name;
+    }
+  } else {
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+    const NXArchInfo* info = NXGetArchInfoFromCpuType(cpu_type, cpu_subtype);
+#pragma clang diagnostic pop
+    if (info) {
+      return info->name;
+    }
+  }
+
+  return kUnknownArchName;
+}
+
+#else
+
+std::optional<ArchInfo> GetArchInfoFromName(const char* arch_name) {
   for (int arch = 0; arch < kNumArchitectures; ++arch) {
-    if (kKnownArchitectures[arch].cputype == cputype) {
-      if (kKnownArchitectures[arch].cpusubtype == cpusubtype) {
-        return &kKnownArchitectures[arch];
-      }
-      if (!candidate) {
-        candidate = &kKnownArchitectures[arch];
-      }
+    if (!strcmp(arch_name, kKnownArchitectures[arch].name)) {
+      return kKnownArchitectures[arch].info;
     }
   }
-  return candidate;
+  return std::nullopt;
 }
 
-struct fat_arch *NXFindBestFatArch(cpu_type_t cputype,
-                                   cpu_subtype_t cpusubtype,
-                                   struct fat_arch *fat_archs,
-                                   uint32_t nfat_archs) {
-  struct fat_arch *candidate = NULL;
-  for (uint32_t f = 0; f < nfat_archs; ++f) {
-    if (fat_archs[f].cputype == cputype) {
-      if (fat_archs[f].cpusubtype == cpusubtype) {
-        return &fat_archs[f];
+const char* GetNameFromCPUType(cpu_type_t cpu_type, cpu_subtype_t cpu_subtype) {
+  const char* candidate = kUnknownArchName;
+  for (int arch = 0; arch < kNumArchitectures; ++arch) {
+    if (kKnownArchitectures[arch].info.cputype == cpu_type) {
+      if (kKnownArchitectures[arch].info.cpusubtype == cpu_subtype) {
+        return kKnownArchitectures[arch].name;
       }
-      if (!candidate) {
-        candidate = &fat_archs[f];
+      if (!strcmp(candidate, kUnknownArchName)) {
+        candidate = kKnownArchitectures[arch].name;
       }
     }
   }
   return candidate;
 }
-#endif  // !__APPLE__
+#endif  // __APPLE__