Return to arch.h CVS log

Up to [Apple XNU] / GNUtools / cctools / include / stuff

Annotation of GNUtools/cctools/include/stuff/arch.h, revision 1.1

1.1     ! root        1: /*
        !             2:  * This file contains the current known set of flags and constants for the
        !             3:  * known architectures.
        !             4:  */
        !             5: #import <mach/machine.h>
        !             6: #import <stuff/bytesex.h>
        !             7: 
        !             8: /*
        !             9:  * The structure describing an architecture flag with the string of the flag
        !            10:  * name, and the cputype and cpusubtype.
        !            11:  */
        !            12: struct arch_flag {
        !            13:     char *name;
        !            14:     cpu_type_t cputype;
        !            15:     cpu_subtype_t cpusubtype;
        !            16: };
        !            17: 
        !            18: /*
        !            19:  * get_arch_from_flag() is passed a name of an architecture flag and returns
        !            20:  * zero if that flag is not known and non-zero if the flag is known.
        !            21:  * If the pointer to the arch_flag is not NULL it is filled in with the
        !            22:  * arch_flag struct that matches the name.
        !            23:  */
        !            24: extern int get_arch_from_flag(
        !            25:     char *name,
        !            26:     struct arch_flag *arch_flag);
        !            27: 
        !            28: /*
        !            29:  * get_arch_from_host() gets the architecture from the host this is running on
        !            30:  * and returns zero if the architecture is not known and zero if the
        !            31:  * architecture is known.  If the parameters family_arch_flag and
        !            32:  * specific_arch_flag are not NULL they get fill in with the family
        !            33:  * architecture and specific architecure for the host.  If the architecture
        !            34:  * is unknown and the parameters are not NULL then all fields are set to zero.
        !            35:  */
        !            36: extern int get_arch_from_host(
        !            37:     struct arch_flag *family_arch_flag,
        !            38:     struct arch_flag *specific_arch_flag);
        !            39: 
        !            40: /*
        !            41:  * get_arch_flags() returns a pointer to an array of all currently know
        !            42:  * architecture flags (terminated with an entry with all zeros).
        !            43:  */
        !            44: extern const struct arch_flag *get_arch_flags(
        !            45:     void);
        !            46: 
        !            47: /*
        !            48:  * arch_usage() is called when an unknown architecture flag is encountered.
        !            49:  * It prints the currently know architecture flags on stderr.
        !            50:  */
        !            51: extern void arch_usage(
        !            52:     void);
        !            53: 
        !            54: /*
        !            55:  * set_arch_flag_name() sets the name field of the specified arch_flag to
        !            56:  * match it's cputype and cpusubtype.  The string is allocated via malloc by
        !            57:  * the routines in "allocate.h" and errors are handled by the routines in
        !            58:  * "error.h".
        !            59:  */
        !            60: extern void set_arch_flag_name(
        !            61:     struct arch_flag *p);
        !            62: 
        !            63: /*
        !            64:  * get_arch_name_from_types() returns the name of the architecture for the
        !            65:  * specified cputype and cpusubtype if known.  If unknown it returns a pointer
        !            66:  * to the string "unknown".
        !            67:  */
        !            68: extern const char *get_arch_name_from_types(
        !            69:     cpu_type_t cputype,
        !            70:     cpu_subtype_t cpusubtype);
        !            71: 
        !            72: /*
        !            73:  * get_arch_family_from_cputype() returns the family architecture for the
        !            74:  * specified cputype if known.  If unknown it returns NULL.
        !            75:  */
        !            76: extern const struct arch_flag *get_arch_family_from_cputype(
        !            77:     cpu_type_t cputype);
        !            78: 
        !            79: /*
        !            80:  * get_byte_sex_from_flag() returns the byte sex of the architecture for the
        !            81:  * specified cputype and cpusubtype if known.  If unknown it returns
        !            82:  * UNKNOWN_BYTE_SEX.  If the bytesex can be determined directly as in the case
        !            83:  * of reading a magic number from a file that should be done and this routine
        !            84:  * should not be used as it could be out of date.
        !            85:  */
        !            86: extern enum byte_sex get_byte_sex_from_flag(
        !            87:     const struct arch_flag *flag);

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.