suyu/breakpad
26
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Mac: update arch_utilities for macOS 13

Browse source 
The NXArch* family is deprecated in macOS 13. This change:
 - Uses the replacements where available
 - Silences deprecation warnings otherwise
 - Removes the Linux cross-compile shims in favor of having completely
 separate implementations for Mac and non-Mac. The logic of the Linux
 versions uses the same prepopulated data as before, but they no longer
 use NXArchInfo.

clang diagnostic disables are necessary due to https://crbug.com/1406057

Bug: chromium:1420654, google-breakpad:880, b/257505171
Change-Id: Iad777915a5a058551cfb3a7d3cf681cce180dfea
Reviewed-on: https://chromium-review.googlesource.com/c/breakpad/breakpad/+/4437109
Reviewed-by: Mark Mentovai <mark@chromium.org>
This commit is contained in:
Leonard Grey 2023-04-27 12:38:54 -04:00
parent 652e7dac80
commit 57bed07ad4
1 changed files with 73 additions and 126 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

197
src/common/mac/arch_utilities.cc
View file

@ -32,69 +32,16 @@
#include "common/mac/arch_utilities.h" #include "common/mac/arch_utilities.h"
#include <mach/machine.h>
#include <mach-o/arch.h> #include <mach-o/arch.h>
#include <mach-o/fat.h> #include <mach-o/fat.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#ifndef CPU_SUBTYPE_ARM_V7S #ifdef __APPLE__
#define CPU_SUBTYPE_ARM_V7S (static_cast<cpu_subtype_t>(11)) #include <mach-o/utils.h>
#endif // CPU_SUBTYPE_ARM_V7S #endif
#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
std::optional<ArchInfo> GetArchInfoFromName(const char* arch_name) {
// TODO: Remove this when the OS knows about arm64.
if (!strcmp("arm64", arch_name))
return ArchInfo{CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_ALL};
if (!strcmp("arm64e", arch_name))
return ArchInfo{CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_E};
// TODO: Remove this when the OS knows about armv7s.
if (!strcmp("armv7s", arch_name))
return ArchInfo{CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7S};
const NXArchInfo* info = NXGetArchInfoFromName(arch_name);
if (info)
return ArchInfo{info->cputype, info->cpusubtype};
return std::nullopt;
}
const char* GetNameFromCPUType(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) {
return "arm64";
}
if (cpu_type == CPU_TYPE_ARM64 && cpu_subtype == CPU_SUBTYPE_ARM64_E) {
return "arm64e";
}
// TODO: Remove this when the OS knows about armv7s.
if (cpu_type == CPU_TYPE_ARM && cpu_subtype == CPU_SUBTYPE_ARM_V7S) {
return "armv7s";
}
const NXArchInfo* info = NXGetArchInfoFromCpuType(cpu_type, cpu_subtype);
if (info)
return info->name;
return kUnknownArchName;
}
// 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 { namespace {
enum Architecture { enum Architecture {
@ -109,59 +56,21 @@ enum Architecture {
kNumArchitectures kNumArchitectures
}; };
struct NamedArchInfo {
const char* name;
ArchInfo info;
};
// enum Architecture above and kKnownArchitectures below // enum Architecture above and kKnownArchitectures below
// must be kept in sync. // must be kept in sync.
const NXArchInfo kKnownArchitectures[] = { constexpr NamedArchInfo kKnownArchitectures[] = {
{ {"i386", {CPU_TYPE_I386, CPU_SUBTYPE_I386_ALL}},
"i386", {"x86_64", {CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_ALL}},
CPU_TYPE_I386, {"x86_64h", {CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_H}},
CPU_SUBTYPE_I386_ALL, {"arm", {CPU_TYPE_ARM, CPU_SUBTYPE_ARM_ALL}},
NX_LittleEndian, {"arm64", {CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_ALL}},
"Intel 80x86" {"arm64e", {CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64E}},
}, {"ppc", {CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_ALL}}};
{
"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"
}
};
} // namespace } // namespace
@ -171,7 +80,7 @@ ArchInfo GetLocalArchInfo(void) {
arch = kArch_i386; arch = kArch_i386;
#elif defined(__x86_64__) #elif defined(__x86_64__)
arch = kArch_x86_64; arch = kArch_x86_64;
#elif defined(__arm64) #elif defined(__arm64__) || defined(__aarch64__)
arch = kArch_arm64; arch = kArch_arm64;
#elif defined(__arm__) #elif defined(__arm__)
arch = kArch_arm; arch = kArch_arm;
@ -180,34 +89,72 @@ ArchInfo GetLocalArchInfo(void) {
#else #else
#error "Unsupported CPU architecture" #error "Unsupported CPU architecture"
#endif #endif
NXArchInfo info = kKnownArchitectures[arch]; return kKnownArchitectures[arch].info;
return {info.cputype, info.cpusubtype};
} }
#ifndef __APPLE__ #ifdef __APPLE__
const NXArchInfo *NXGetArchInfoFromName(const char *name) { std::optional<ArchInfo> GetArchInfoFromName(const char* arch_name) {
if (__builtin_available(macOS 13.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 std::nullopt;
}
const char* GetNameFromCPUType(cpu_type_t cpu_type, cpu_subtype_t cpu_subtype) {
if (__builtin_available(macOS 13.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) { for (int arch = 0; arch < kNumArchitectures; ++arch) {
if (!strcmp(name, kKnownArchitectures[arch].name)) { if (!strcmp(arch_name, kKnownArchitectures[arch].name)) {
return &kKnownArchitectures[arch]; return kKnownArchitectures[arch].info;
} }
} }
return NULL; return std::nullopt;
} }
const NXArchInfo *NXGetArchInfoFromCpuType(cpu_type_t cputype, const char* GetNameFromCPUType(cpu_type_t cpu_type, cpu_subtype_t cpu_subtype) {
cpu_subtype_t cpusubtype) { const char* candidate = kUnknownArchName;
const NXArchInfo *candidate = NULL;
for (int arch = 0; arch < kNumArchitectures; ++arch) { for (int arch = 0; arch < kNumArchitectures; ++arch) {
if (kKnownArchitectures[arch].cputype == cputype) { if (kKnownArchitectures[arch].info.cputype == cpu_type) {
if (kKnownArchitectures[arch].cpusubtype == cpusubtype) { if (kKnownArchitectures[arch].info.cpusubtype == cpu_subtype) {
return &kKnownArchitectures[arch]; return kKnownArchitectures[arch].name;
} }
if (!candidate) { if (!strcmp(candidate, kUnknownArchName)) {
candidate = &kKnownArchitectures[arch]; candidate = kKnownArchitectures[arch].name;
} }
} }
} }
return candidate; return candidate;
} }
#endif // !__APPLE__ #endif // __APPLE__