diff options
Diffstat (limited to 'third_party/rust/goblin/src/mach/constants.rs')
| -rw-r--r-- | third_party/rust/goblin/src/mach/constants.rs | 448 |
1 files changed, 448 insertions, 0 deletions
diff --git a/third_party/rust/goblin/src/mach/constants.rs b/third_party/rust/goblin/src/mach/constants.rs new file mode 100644 index 0000000000..b5afc427ec --- /dev/null +++ b/third_party/rust/goblin/src/mach/constants.rs @@ -0,0 +1,448 @@ +//! Miscellaneous constants used inside of and when constructing, Mach-o binaries +// Convienence constants for return values from dyld_get_sdk_version() and friends. +pub const DYLD_MACOSX_VERSION_10_4: u32 = 0x000A_0400; +pub const DYLD_MACOSX_VERSION_10_5: u32 = 0x000A_0500; +pub const DYLD_MACOSX_VERSION_10_6: u32 = 0x000A_0600; +pub const DYLD_MACOSX_VERSION_10_7: u32 = 0x000A_0700; +pub const DYLD_MACOSX_VERSION_10_8: u32 = 0x000A_0800; +pub const DYLD_MACOSX_VERSION_10_9: u32 = 0x000A_0900; +pub const DYLD_MACOSX_VERSION_10_10: u32 = 0x000A_0A00; +pub const DYLD_MACOSX_VERSION_10_11: u32 = 0x000A_0B00; +pub const DYLD_MACOSX_VERSION_10_12: u32 = 0x000A_0C00; +pub const DYLD_MACOSX_VERSION_10_13: u32 = 0x000A_0D00; + +pub const DYLD_IOS_VERSION_2_0: u32 = 0x0002_0000; +pub const DYLD_IOS_VERSION_2_1: u32 = 0x0002_0100; +pub const DYLD_IOS_VERSION_2_2: u32 = 0x0002_0200; +pub const DYLD_IOS_VERSION_3_0: u32 = 0x0003_0000; +pub const DYLD_IOS_VERSION_3_1: u32 = 0x0003_0100; +pub const DYLD_IOS_VERSION_3_2: u32 = 0x0003_0200; +pub const DYLD_IOS_VERSION_4_0: u32 = 0x0004_0000; +pub const DYLD_IOS_VERSION_4_1: u32 = 0x0004_0100; +pub const DYLD_IOS_VERSION_4_2: u32 = 0x0004_0200; +pub const DYLD_IOS_VERSION_4_3: u32 = 0x0004_0300; +pub const DYLD_IOS_VERSION_5_0: u32 = 0x0005_0000; +pub const DYLD_IOS_VERSION_5_1: u32 = 0x0005_0100; +pub const DYLD_IOS_VERSION_6_0: u32 = 0x0006_0000; +pub const DYLD_IOS_VERSION_6_1: u32 = 0x0006_0100; +pub const DYLD_IOS_VERSION_7_0: u32 = 0x0007_0000; +pub const DYLD_IOS_VERSION_7_1: u32 = 0x0007_0100; +pub const DYLD_IOS_VERSION_8_0: u32 = 0x0008_0000; +pub const DYLD_IOS_VERSION_9_0: u32 = 0x0009_0000; +pub const DYLD_IOS_VERSION_10_0: u32 = 0x000A_0000; +pub const DYLD_IOS_VERSION_11_0: u32 = 0x000B_0000; + +// Segment and Section Constants + +// The flags field of a section structure is separated into two parts a section +// type and section attributes. The section types are mutually exclusive (it +// can only have one type) but the section attributes are not (it may have more +// than one attribute). +/// 256 section types +pub const SECTION_TYPE: u32 = 0x0000_00ff; +/// 24 section attributes +pub const SECTION_ATTRIBUTES: u32 = 0xffff_ff00; + +// Constants for the type of a section +/// regular section +pub const S_REGULAR: u32 = 0x0; +/// zero fill on demand section +pub const S_ZEROFILL: u32 = 0x1; +/// section with only literal C strings +pub const S_CSTRING_LITERALS: u32 = 0x2; +/// section with only 4 byte literals +pub const S_4BYTE_LITERALS: u32 = 0x3; +/// section with only 8 byte literals +pub const S_8BYTE_LITERALS: u32 = 0x4; +/// section with only pointers to +pub const S_LITERAL_POINTERS: u32 = 0x5; + +// literals +// For the two types of symbol pointers sections and the symbol stubs section +// they have indirect symbol table entries. For each of the entries in the +// section the indirect symbol table entries, in corresponding order in the +// indirect symbol table, start at the index stored in the reserved1 field +// of the section structure. Since the indirect symbol table entries +// correspond to the entries in the section the number of indirect symbol table +// entries is inferred from the size of the section divided by the size of the +// entries in the section. For symbol pointers sections the size of the entries +// in the section is 4 bytes and for symbol stubs sections the byte size of the +// stubs is stored in the reserved2 field of the section structure. +/// section with only non-lazy symbol pointers +pub const S_NON_LAZY_SYMBOL_POINTERS: u32 = 0x6; +/// section with only lazy symbol pointers +pub const S_LAZY_SYMBOL_POINTERS: u32 = 0x7; +/// section with only symbol stubs, byte size of stub in the reserved2 field +pub const S_SYMBOL_STUBS: u32 = 0x8; +/// section with only function pointers for initialization +pub const S_MOD_INIT_FUNC_POINTERS: u32 = 0x9; +/// section with only function pointers for termination +pub const S_MOD_TERM_FUNC_POINTERS: u32 = 0xa; +/// section contains symbols that are to be coalesced +pub const S_COALESCED: u32 = 0xb; +/// zero fill on demand section that can be larger than 4 gigabytes) +pub const S_GB_ZEROFILL: u32 = 0xc; +/// section with only pairs of function pointers for interposing +pub const S_INTERPOSING: u32 = 0xd; +/// section with only 16 byte literals +pub const S_16BYTE_LITERALS: u32 = 0xe; +/// section contains DTrace Object Format +pub const S_DTRACE_DOF: u32 = 0xf; +/// section with only lazy symbol pointers to lazy loaded dylibs +pub const S_LAZY_DYLIB_SYMBOL_POINTERS: u32 = 0x10; + +// Section types to support thread local variables +/// template of initial values for TLVs +pub const S_THREAD_LOCAL_REGULAR: u32 = 0x11; +/// template of initial values for TLVs +pub const S_THREAD_LOCAL_ZEROFILL: u32 = 0x12; +/// TLV descriptors +pub const S_THREAD_LOCAL_VARIABLES: u32 = 0x13; +/// pointers to TLV descriptors +pub const S_THREAD_LOCAL_VARIABLE_POINTERS: u32 = 0x14; +/// functions to call to initialize TLV values +pub const S_THREAD_LOCAL_INIT_FUNCTION_POINTERS: u32 = 0x15; + +// Constants for the section attributes part of the flags field of a section +// structure. +/// User setable attributes +pub const SECTION_ATTRIBUTES_USR: u32 = 0xff00_0000; +/// section contains only true machine instructions +pub const S_ATTR_PURE_INSTRUCTIONS: u32 = 0x8000_0000; +/// section contains coalesced symbols that are not to be in a ranlib table of contents +pub const S_ATTR_NO_TOC: u32 = 0x4000_0000; +/// ok to strip static symbols in this section in files with the MH_DYLDLINK flag +pub const S_ATTR_STRIP_STATIC_SYMS: u32 = 0x2000_0000; +/// no dead stripping +pub const S_ATTR_NO_DEAD_STRIP: u32 = 0x1000_0000; +/// blocks are live if they reference live blocks +pub const S_ATTR_LIVE_SUPPORT: u32 = 0x0800_0000; +/// Used with i386 code stubs written on by dyld +pub const S_ATTR_SELF_MODIFYING_CODE: u32 = 0x0400_0000; + +// If a segment contains any sections marked with S_ATTR_DEBUG then all +// sections in that segment must have this attribute. No section other than +// a section marked with this attribute may reference the contents of this +// section. A section with this attribute may contain no symbols and must have +// a section type S_REGULAR. The static linker will not copy section contents +// from sections with this attribute into its output file. These sections +// generally contain DWARF debugging info. +/// debug section +pub const S_ATTR_DEBUG: u32 = 0x0200_0000; +/// system setable attributes +pub const SECTION_ATTRIBUTES_SYS: u32 = 0x00ff_ff00; +/// section contains some machine instructions +pub const S_ATTR_SOME_INSTRUCTIONS: u32 = 0x0000_0400; +/// section has external relocation entries +pub const S_ATTR_EXT_RELOC: u32 = 0x0000_0200; +/// section has local relocation entries +pub const S_ATTR_LOC_RELOC: u32 = 0x0000_0100; + +// The names of segments and sections in them are mostly meaningless to the +// link-editor. But there are few things to support traditional UNIX +// executables that require the link-editor and assembler to use some names +// agreed upon by convention. +// The initial protection of the "__TEXT" segment has write protection turned +// off (not writeable). +// The link-editor will allocate common symbols at the end of the "__common" +// section in the "__DATA" segment. It will create the section and segment +// if needed. + +// The currently known segment names and the section names in those segments +/// the pagezero segment which has no protections and catches NULL references for MH_EXECUTE files +pub const SEG_PAGEZERO: &str = "__PAGEZERO"; +/// the tradition UNIX text segment +pub const SEG_TEXT: &str = "__TEXT"; +/// the real text part of the text section no headers, and no padding +pub const SECT_TEXT: &str = "__text"; +/// the fvmlib initialization section +pub const SECT_FVMLIB_INIT0: &str = "__fvmlib_init0"; +/// the section following the fvmlib initialization section +pub const SECT_FVMLIB_INIT1: &str = "__fvmlib_init1"; +/// the tradition UNIX data segment +pub const SEG_DATA: &str = "__DATA"; +/// the real initialized data section no padding, no bss overlap +pub const SECT_DATA: &str = "__data"; +/// the real uninitialized data sectionno padding +pub const SECT_BSS: &str = "__bss"; +/// the section common symbols are allocated in by the link editor +pub const SECT_COMMON: &str = "__common"; +/// objective-C runtime segment +pub const SEG_OBJC: &str = "__OBJC"; +/// symbol table +pub const SECT_OBJC_SYMBOLS: &str = "__symbol_table"; +/// module information +pub const SECT_OBJC_MODULES: &str = "__module_info"; +/// string table +pub const SECT_OBJC_STRINGS: &str = "__selector_strs"; +/// string table +pub const SECT_OBJC_REFS: &str = "__selector_refs"; +/// the icon segment +pub const SEG_ICON: &str = "__ICON"; +/// the icon headers +pub const SECT_ICON_HEADER: &str = "__header"; +/// the icons in tiff format +pub const SECT_ICON_TIFF: &str = "__tiff"; +/// the segment containing all structs created and maintained by the link editor. Created with -seglinkedit option to ld(1) for MH_EXECUTE and FVMLIB file types only +pub const SEG_LINKEDIT: &str = "__LINKEDIT"; +/// the unix stack segment +pub const SEG_UNIXSTACK: &str = "__UNIXSTACK"; +/// the segment for the self (dyld) modifing code stubs that has read, write and execute permissions +pub const SEG_IMPORT: &str = "__IMPORT"; + +/// Segment is readable. +pub const VM_PROT_READ: u32 = 0x1; +/// Segment is writable. +pub const VM_PROT_WRITE: u32 = 0x2; +/// Segment is executable. +pub const VM_PROT_EXECUTE: u32 = 0x4; + +pub mod cputype { + + /// An alias for u32 + pub type CpuType = u32; + /// An alias for u32 + pub type CpuSubType = u32; + + /// the mask for CPU feature flags + pub const CPU_SUBTYPE_MASK: u32 = 0xff00_0000; + /// mask for architecture bits + pub const CPU_ARCH_MASK: CpuType = 0xff00_0000; + /// the mask for 64 bit ABI + pub const CPU_ARCH_ABI64: CpuType = 0x0100_0000; + /// the mask for ILP32 ABI on 64 bit hardware + pub const CPU_ARCH_ABI64_32: CpuType = 0x0200_0000; + + // CPU Types + pub const CPU_TYPE_ANY: CpuType = !0; + pub const CPU_TYPE_VAX: CpuType = 1; + pub const CPU_TYPE_MC680X0: CpuType = 6; + pub const CPU_TYPE_X86: CpuType = 7; + pub const CPU_TYPE_I386: CpuType = CPU_TYPE_X86; + pub const CPU_TYPE_X86_64: CpuType = (CPU_TYPE_X86 | CPU_ARCH_ABI64); + pub const CPU_TYPE_MIPS: CpuType = 8; + pub const CPU_TYPE_MC98000: CpuType = 10; + pub const CPU_TYPE_HPPA: CpuType = 11; + pub const CPU_TYPE_ARM: CpuType = 12; + pub const CPU_TYPE_ARM64: CpuType = (CPU_TYPE_ARM | CPU_ARCH_ABI64); + pub const CPU_TYPE_ARM64_32: CpuType = (CPU_TYPE_ARM | CPU_ARCH_ABI64_32); + pub const CPU_TYPE_MC88000: CpuType = 13; + pub const CPU_TYPE_SPARC: CpuType = 14; + pub const CPU_TYPE_I860: CpuType = 15; + pub const CPU_TYPE_ALPHA: CpuType = 16; + pub const CPU_TYPE_POWERPC: CpuType = 18; + pub const CPU_TYPE_POWERPC64: CpuType = (CPU_TYPE_POWERPC | CPU_ARCH_ABI64); + + // CPU Subtypes + pub const CPU_SUBTYPE_MULTIPLE: CpuSubType = !0; + pub const CPU_SUBTYPE_LITTLE_ENDIAN: CpuSubType = 0; + pub const CPU_SUBTYPE_BIG_ENDIAN: CpuSubType = 1; + pub const CPU_SUBTYPE_VAX_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_VAX780: CpuSubType = 1; + pub const CPU_SUBTYPE_VAX785: CpuSubType = 2; + pub const CPU_SUBTYPE_VAX750: CpuSubType = 3; + pub const CPU_SUBTYPE_VAX730: CpuSubType = 4; + pub const CPU_SUBTYPE_UVAXI: CpuSubType = 5; + pub const CPU_SUBTYPE_UVAXII: CpuSubType = 6; + pub const CPU_SUBTYPE_VAX8200: CpuSubType = 7; + pub const CPU_SUBTYPE_VAX8500: CpuSubType = 8; + pub const CPU_SUBTYPE_VAX8600: CpuSubType = 9; + pub const CPU_SUBTYPE_VAX8650: CpuSubType = 10; + pub const CPU_SUBTYPE_VAX8800: CpuSubType = 11; + pub const CPU_SUBTYPE_UVAXIII: CpuSubType = 12; + pub const CPU_SUBTYPE_MC680X0_ALL: CpuSubType = 1; + pub const CPU_SUBTYPE_MC68030: CpuSubType = 1; /* compat */ + pub const CPU_SUBTYPE_MC68040: CpuSubType = 2; + pub const CPU_SUBTYPE_MC68030_ONLY: CpuSubType = 3; + + macro_rules! CPU_SUBTYPE_INTEL { + ($f:expr, $m:expr) => ({ + ($f) + (($m) << 4) + }) + } + + pub const CPU_SUBTYPE_I386_ALL: CpuSubType = CPU_SUBTYPE_INTEL!(3, 0); + pub const CPU_SUBTYPE_386: CpuSubType = CPU_SUBTYPE_INTEL!(3, 0); + pub const CPU_SUBTYPE_486: CpuSubType = CPU_SUBTYPE_INTEL!(4, 0); + pub const CPU_SUBTYPE_486SX: CpuSubType = CPU_SUBTYPE_INTEL!(4, 8); // 8 << 4 = 128 + pub const CPU_SUBTYPE_586: CpuSubType = CPU_SUBTYPE_INTEL!(5, 0); + pub const CPU_SUBTYPE_PENT: CpuSubType = CPU_SUBTYPE_INTEL!(5, 0); + pub const CPU_SUBTYPE_PENTPRO: CpuSubType = CPU_SUBTYPE_INTEL!(6, 1); + pub const CPU_SUBTYPE_PENTII_M3: CpuSubType = CPU_SUBTYPE_INTEL!(6, 3); + pub const CPU_SUBTYPE_PENTII_M5: CpuSubType = CPU_SUBTYPE_INTEL!(6, 5); + pub const CPU_SUBTYPE_CELERON: CpuSubType = CPU_SUBTYPE_INTEL!(7, 6); + pub const CPU_SUBTYPE_CELERON_MOBILE: CpuSubType = CPU_SUBTYPE_INTEL!(7, 7); + pub const CPU_SUBTYPE_PENTIUM_3: CpuSubType = CPU_SUBTYPE_INTEL!(8, 0); + pub const CPU_SUBTYPE_PENTIUM_3_M: CpuSubType = CPU_SUBTYPE_INTEL!(8, 1); + pub const CPU_SUBTYPE_PENTIUM_3_XEON: CpuSubType = CPU_SUBTYPE_INTEL!(8, 2); + pub const CPU_SUBTYPE_PENTIUM_M: CpuSubType = CPU_SUBTYPE_INTEL!(9, 0); + pub const CPU_SUBTYPE_PENTIUM_4: CpuSubType = CPU_SUBTYPE_INTEL!(10, 0); + pub const CPU_SUBTYPE_PENTIUM_4_M: CpuSubType = CPU_SUBTYPE_INTEL!(10, 1); + pub const CPU_SUBTYPE_ITANIUM: CpuSubType = CPU_SUBTYPE_INTEL!(11, 0); + pub const CPU_SUBTYPE_ITANIUM_2: CpuSubType = CPU_SUBTYPE_INTEL!(11, 1); + pub const CPU_SUBTYPE_XEON: CpuSubType = CPU_SUBTYPE_INTEL!(12, 0); + pub const CPU_SUBTYPE_XEON_MP: CpuSubType = CPU_SUBTYPE_INTEL!(12, 1); + pub const CPU_SUBTYPE_INTEL_FAMILY_MAX: CpuSubType = 15; + pub const CPU_SUBTYPE_INTEL_MODEL_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_X86_ALL: CpuSubType = 3; + pub const CPU_SUBTYPE_X86_64_ALL: CpuSubType = 3; + pub const CPU_SUBTYPE_X86_ARCH1: CpuSubType = 4; + pub const CPU_SUBTYPE_X86_64_H: CpuSubType = 8; + pub const CPU_SUBTYPE_MIPS_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_MIPS_R2300: CpuSubType = 1; + pub const CPU_SUBTYPE_MIPS_R2600: CpuSubType = 2; + pub const CPU_SUBTYPE_MIPS_R2800: CpuSubType = 3; + pub const CPU_SUBTYPE_MIPS_R2000A: CpuSubType = 4; + pub const CPU_SUBTYPE_MIPS_R2000: CpuSubType = 5; + pub const CPU_SUBTYPE_MIPS_R3000A: CpuSubType = 6; + pub const CPU_SUBTYPE_MIPS_R3000: CpuSubType = 7; + pub const CPU_SUBTYPE_MC98000_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_MC98601: CpuSubType = 1; + pub const CPU_SUBTYPE_HPPA_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_HPPA_7100: CpuSubType = 0; + pub const CPU_SUBTYPE_HPPA_7100LC: CpuSubType = 1; + pub const CPU_SUBTYPE_MC88000_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_MC88100: CpuSubType = 1; + pub const CPU_SUBTYPE_MC88110: CpuSubType = 2; + pub const CPU_SUBTYPE_SPARC_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_I860_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_I860_860: CpuSubType = 1; + pub const CPU_SUBTYPE_POWERPC_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_POWERPC_601: CpuSubType = 1; + pub const CPU_SUBTYPE_POWERPC_602: CpuSubType = 2; + pub const CPU_SUBTYPE_POWERPC_603: CpuSubType = 3; + pub const CPU_SUBTYPE_POWERPC_603E: CpuSubType = 4; + pub const CPU_SUBTYPE_POWERPC_603EV: CpuSubType = 5; + pub const CPU_SUBTYPE_POWERPC_604: CpuSubType = 6; + pub const CPU_SUBTYPE_POWERPC_604E: CpuSubType = 7; + pub const CPU_SUBTYPE_POWERPC_620: CpuSubType = 8; + pub const CPU_SUBTYPE_POWERPC_750: CpuSubType = 9; + pub const CPU_SUBTYPE_POWERPC_7400: CpuSubType = 10; + pub const CPU_SUBTYPE_POWERPC_7450: CpuSubType = 11; + pub const CPU_SUBTYPE_POWERPC_970: CpuSubType = 100; + pub const CPU_SUBTYPE_ARM_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_ARM_V4T: CpuSubType = 5; + pub const CPU_SUBTYPE_ARM_V6: CpuSubType = 6; + pub const CPU_SUBTYPE_ARM_V5TEJ: CpuSubType = 7; + pub const CPU_SUBTYPE_ARM_XSCALE: CpuSubType = 8; + pub const CPU_SUBTYPE_ARM_V7: CpuSubType = 9; + pub const CPU_SUBTYPE_ARM_V7F: CpuSubType = 10; + pub const CPU_SUBTYPE_ARM_V7S: CpuSubType = 11; + pub const CPU_SUBTYPE_ARM_V7K: CpuSubType = 12; + pub const CPU_SUBTYPE_ARM_V6M: CpuSubType = 14; + pub const CPU_SUBTYPE_ARM_V7M: CpuSubType = 15; + pub const CPU_SUBTYPE_ARM_V7EM: CpuSubType = 16; + pub const CPU_SUBTYPE_ARM_V8: CpuSubType = 13; + pub const CPU_SUBTYPE_ARM64_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_ARM64_V8: CpuSubType = 1; + pub const CPU_SUBTYPE_ARM64_E: CpuSubType = 2; + pub const CPU_SUBTYPE_ARM64_32_ALL: CpuSubType = 0; + pub const CPU_SUBTYPE_ARM64_32_V8: CpuSubType = 1; + + macro_rules! cpu_flag_mapping { + ( + $(($name:expr, $cputype:ident, $cpusubtype:ident),)* + ) => { + fn get_arch_from_flag_no_alias(name: &str) -> Option<(CpuType, CpuSubType)> { + match name { + $($name => Some(($cputype, $cpusubtype)),)* + _ => None + } + } + + /// Get the architecture name from cputype and cpusubtype + pub fn get_arch_name_from_types(cputype: CpuType, cpusubtype: CpuSubType) + -> Option<&'static str> { + match (cputype, cpusubtype) { + $(($cputype, $cpusubtype) => Some($name),)* + (_, _) => None + } + } + } + } + + /// Get the cputype and cpusubtype from a name + pub fn get_arch_from_flag(name: &str) -> Option<(CpuType, CpuSubType)> { + get_arch_from_flag_no_alias(name).or_else(|| { + // we also handle some common aliases + match name { + // these are used by apple + "pentium" => Some((CPU_TYPE_I386, CPU_SUBTYPE_PENT)), + "pentpro" => Some((CPU_TYPE_I386, CPU_SUBTYPE_PENTPRO)), + // these are used commonly for consistency + "x86" => Some((CPU_TYPE_I386, CPU_SUBTYPE_I386_ALL)), + _ => None, + } + }) + } + + cpu_flag_mapping! { + // generic types + ("any", CPU_TYPE_ANY, CPU_SUBTYPE_MULTIPLE), + ("little", CPU_TYPE_ANY, CPU_SUBTYPE_LITTLE_ENDIAN), + ("big", CPU_TYPE_ANY, CPU_SUBTYPE_BIG_ENDIAN), + + // macho names + ("ppc64", CPU_TYPE_POWERPC64, CPU_SUBTYPE_POWERPC_ALL), + ("x86_64", CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_ALL), + ("x86_64h", CPU_TYPE_X86_64, CPU_SUBTYPE_X86_64_H), + ("arm64", CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_ALL), + ("arm64_32", CPU_TYPE_ARM64_32, CPU_SUBTYPE_ARM64_32_ALL), + ("ppc970-64", CPU_TYPE_POWERPC64, CPU_SUBTYPE_POWERPC_970), + ("ppc", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_ALL), + ("i386", CPU_TYPE_I386, CPU_SUBTYPE_I386_ALL), + ("m68k", CPU_TYPE_MC680X0, CPU_SUBTYPE_MC680X0_ALL), + ("hppa", CPU_TYPE_HPPA, CPU_SUBTYPE_HPPA_ALL), + ("sparc", CPU_TYPE_SPARC, CPU_SUBTYPE_SPARC_ALL), + ("m88k", CPU_TYPE_MC88000, CPU_SUBTYPE_MC88000_ALL), + ("i860", CPU_TYPE_I860, CPU_SUBTYPE_I860_ALL), + ("arm", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_ALL), + ("ppc601", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_601), + ("ppc603", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_603), + ("ppc603e", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_603E), + ("ppc603ev", CPU_TYPE_POWERPC,CPU_SUBTYPE_POWERPC_603EV), + ("ppc604", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_604), + ("ppc604e",CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_604E), + ("ppc750", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_750), + ("ppc7400", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_7400), + ("ppc7450", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_7450), + ("ppc970", CPU_TYPE_POWERPC, CPU_SUBTYPE_POWERPC_970), + ("i486", CPU_TYPE_I386, CPU_SUBTYPE_486), + ("i486SX", CPU_TYPE_I386, CPU_SUBTYPE_486SX), + ("i586", CPU_TYPE_I386, CPU_SUBTYPE_586), + ("i686", CPU_TYPE_I386, CPU_SUBTYPE_PENTPRO), + ("pentIIm3", CPU_TYPE_I386, CPU_SUBTYPE_PENTII_M3), + ("pentIIm5", CPU_TYPE_I386, CPU_SUBTYPE_PENTII_M5), + ("pentium4", CPU_TYPE_I386, CPU_SUBTYPE_PENTIUM_4), + ("m68030", CPU_TYPE_MC680X0, CPU_SUBTYPE_MC68030_ONLY), + ("m68040", CPU_TYPE_MC680X0, CPU_SUBTYPE_MC68040), + ("hppa7100LC", CPU_TYPE_HPPA, CPU_SUBTYPE_HPPA_7100LC), + ("armv4t", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V4T), + ("armv5", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V5TEJ), + ("xscale", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_XSCALE), + ("armv6", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V6), + ("armv6m", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V6M), + ("armv7", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7), + ("armv7f", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7F), + ("armv7s", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7S), + ("armv7k", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7K), + ("armv7m", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7M), + ("armv7em", CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7EM), + ("arm64v8", CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_V8), + ("arm64e", CPU_TYPE_ARM64, CPU_SUBTYPE_ARM64_E), + ("arm64_32_v8", CPU_TYPE_ARM64_32, CPU_SUBTYPE_ARM64_32_V8), + } +} + +#[cfg(test)] +mod tests { + #[test] + fn test_basic_mapping() { + use super::cputype::*; + + assert_eq!(get_arch_from_flag("armv7"), Some((CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7))); + assert_eq!(get_arch_name_from_types(CPU_TYPE_ARM, CPU_SUBTYPE_ARM_V7), Some("armv7")); + assert_eq!(get_arch_from_flag("i386"), Some((CPU_TYPE_I386, CPU_SUBTYPE_I386_ALL))); + assert_eq!(get_arch_from_flag("x86"), Some((CPU_TYPE_I386, CPU_SUBTYPE_I386_ALL))); + } +} |