//! 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 /// /// When using this method to determine the architecture /// name of an instance of /// [`goblin::mach::header::Header`](/goblin/mach/header/struct.Header.html), /// use the provided method /// [`cputype()`](/goblin/mach/header/struct.Header.html#method.cputype) and /// [`cpusubtype()`](/goblin/mach/header/struct.Header.html#method.cpusubtype) /// instead of corresponding field `cputype` and `cpusubtype`. /// /// For example: /// /// ```rust /// use std::fs::read; /// use goblin::mach::constants::cputype::get_arch_name_from_types; /// use goblin::mach::Mach; /// /// read("path/to/macho").and_then(|buf| { /// if let Ok(Mach::Binary(a)) = Mach::parse(&buf) { /// println!("arch name: {}", get_arch_name_from_types(a.header.cputype(), a.header.cpusubtype()).unwrap()); /// } /// Ok(()) /// }); /// ``` 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)) ); } }