constants.rs - mozsearch

//! 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))

);

Revision control

Copy as Markdown

Other Tools