path: root/contrib/tools/yasm/libyasm/arch.h

/** 
 * \file libyasm/arch.h 
 * \brief YASM architecture interface. 
 * 
 * \license 
 *  Copyright (C) 2002-2007  Peter Johnson 
 * 
 * Redistribution and use in source and binary forms, with or without 
 * modification, are permitted provided that the following conditions 
 * are met: 
 *  - Redistributions of source code must retain the above copyright 
 *    notice, this list of conditions and the following disclaimer. 
 *  - Redistributions in binary form must reproduce the above copyright 
 *    notice, this list of conditions and the following disclaimer in the 
 *    documentation and/or other materials provided with the distribution. 
 * 
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND OTHER CONTRIBUTORS ``AS IS'' 
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR OTHER CONTRIBUTORS BE 
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
 * POSSIBILITY OF SUCH DAMAGE. 
 * \endlicense 
 */ 
#ifndef YASM_ARCH_H 
#define YASM_ARCH_H 
 
/** Errors that may be returned by yasm_arch_module::create(). */ 
typedef enum yasm_arch_create_error { 
    YASM_ARCH_CREATE_OK = 0,            /**< No error. */ 
    YASM_ARCH_CREATE_BAD_MACHINE,       /**< Unrecognized machine name. */ 
    YASM_ARCH_CREATE_BAD_PARSER         /**< Unrecognized parser name. */ 
} yasm_arch_create_error; 
 
/** Return values for yasm_arch_module::parse_check_insnprefix(). */ 
typedef enum yasm_arch_insnprefix { 
    YASM_ARCH_NOTINSNPREFIX = 0,        /**< Unrecognized */ 
    YASM_ARCH_INSN,                     /**< An instruction */ 
    YASM_ARCH_PREFIX                    /**< An instruction prefix */ 
} yasm_arch_insnprefix; 
 
/** Types of registers / target modifiers that may be returned by 
 * yasm_arch_module::parse_check_regtmod(). 
 */ 
typedef enum yasm_arch_regtmod { 
    YASM_ARCH_NOTREGTMOD = 0,           /**< Unrecognized */ 
    YASM_ARCH_REG,                      /**< A "normal" register */ 
    YASM_ARCH_REGGROUP,                 /**< A group of indexable registers */ 
    YASM_ARCH_SEGREG,                   /**< A segment register */ 
    YASM_ARCH_TARGETMOD                 /**< A target modifier (for jumps) */ 
} yasm_arch_regtmod; 
 
#ifndef YASM_DOXYGEN 
/** Base #yasm_arch structure.  Must be present as the first element in any 
 * #yasm_arch implementation. 
 */ 
typedef struct yasm_arch_base { 
    /** #yasm_arch_module implementation for this architecture. */ 
    const struct yasm_arch_module *module; 
} yasm_arch_base; 
#endif 
 
/** YASM machine subtype.  A number of different machine types may be 
 * associated with a single architecture.  These may be specific CPU's, but 
 * the ABI used to interface with the architecture should be the primary 
 * differentiator between machines.  Some object formats (ELF) use the machine 
 * to determine parameters within the generated output. 
 */ 
typedef struct yasm_arch_machine { 
    /** One-line description of the machine. */ 
    const char *name; 
 
    /** Keyword used to select machine. */ 
    const char *keyword; 
} yasm_arch_machine; 
 
/** YASM architecture module interface. 
 * \note All "data" in parser-related functions (yasm_arch_parse_*) needs to 
 *       start the parse initialized to 0 to make it okay for a parser-related 
 *       function to use/check previously stored data to see if it's been 
 *       called before on the same piece of data. 
 */ 
typedef struct yasm_arch_module { 
    /** One-line description of the architecture. 
     * Call yasm_arch_name() to get the name of a particular #yasm_arch. 
     */ 
    const char *name; 
 
    /** Keyword used to select architecture. 
     * Call yasm_arch_keyword() to get the keyword of a particular #yasm_arch. 
     */ 
    const char *keyword; 
 
    /** NULL-terminated list of directives.  NULL if none. */ 
    /*@null@*/ const yasm_directive *directives; 
 
    /** Create architecture. 
     * Module-level implementation of yasm_arch_create(). 
     * Call yasm_arch_create() instead of calling this function. 
     */ 
    /*@only@*/ yasm_arch * (*create) (const char *machine, const char *parser, 
                                      /*@out@*/ yasm_arch_create_error *error); 
 
    /** Module-level implementation of yasm_arch_destroy(). 
     * Call yasm_arch_destroy() instead of calling this function. 
     */ 
    void (*destroy) (/*@only@*/ yasm_arch *arch); 
 
    /** Module-level implementation of yasm_arch_get_machine(). 
     * Call yasm_arch_get_machine() instead of calling this function. 
     */ 
    const char * (*get_machine) (const yasm_arch *arch); 
 
    /** Module-level implementation of yasm_arch_get_address_size(). 
     * Call yasm_arch_get_address_size() instead of calling this function. 
     */ 
    unsigned int (*get_address_size) (const yasm_arch *arch); 
 
    /** Module-level implementation of yasm_arch_set_var(). 
     * Call yasm_arch_set_var() instead of calling this function. 
     */ 
    int (*set_var) (yasm_arch *arch, const char *var, unsigned long val); 
 
    /** Module-level implementation of yasm_arch_parse_check_insnprefix(). 
     * Call yasm_arch_parse_check_insnprefix() instead of calling this function. 
     */ 
    yasm_arch_insnprefix (*parse_check_insnprefix) 
        (yasm_arch *arch, const char *id, size_t id_len, unsigned long line, 
         /*@out@*/ /*@only@*/ yasm_bytecode **bc, /*@out@*/ uintptr_t *prefix); 
 
    /** Module-level implementation of yasm_arch_parse_check_regtmod(). 
     * Call yasm_arch_parse_check_regtmod() instead of calling this function. 
     */ 
    yasm_arch_regtmod (*parse_check_regtmod) 
        (yasm_arch *arch, const char *id, size_t id_len, 
         /*@out@*/ uintptr_t *data); 
 
    /** Module-level implementation of yasm_arch_get_fill(). 
     * Call yasm_arch_get_fill() instead of calling this function. 
     */ 
    const unsigned char ** (*get_fill) (const yasm_arch *arch); 
 
    /** Module-level implementation of yasm_arch_floatnum_tobytes(). 
     * Call yasm_arch_floatnum_tobytes() instead of calling this function. 
     */ 
    int (*floatnum_tobytes) (yasm_arch *arch, const yasm_floatnum *flt, 
                             unsigned char *buf, size_t destsize, 
                             size_t valsize, size_t shift, int warn); 
 
    /** Module-level implementation of yasm_arch_intnum_tobytes(). 
     * Call yasm_arch_intnum_tobytes() instead of calling this function. 
     */ 
    int (*intnum_tobytes) (yasm_arch *arch, const yasm_intnum *intn, 
                           unsigned char *buf, size_t destsize, size_t valsize, 
                           int shift, const yasm_bytecode *bc, 
                           int warn); 
 
    /** Module-level implementation of yasm_arch_get_reg_size(). 
     * Call yasm_arch_get_reg_size() instead of calling this function. 
     */ 
    unsigned int (*get_reg_size) (yasm_arch *arch, uintptr_t reg); 
 
    /** Module-level implementation of yasm_arch_reggroup_get_reg(). 
     * Call yasm_arch_reggroup_get_reg() instead of calling this function. 
     */ 
    uintptr_t (*reggroup_get_reg) (yasm_arch *arch, uintptr_t reggroup, 
                                   unsigned long regindex); 
 
    /** Module-level implementation of yasm_arch_reg_print(). 
     * Call yasm_arch_reg_print() instead of calling this function. 
     */ 
    void (*reg_print) (yasm_arch *arch, uintptr_t reg, FILE *f); 
 
    /** Module-level implementation of yasm_arch_segreg_print(). 
     * Call yasm_arch_segreg_print() instead of calling this function. 
     */ 
    void (*segreg_print) (yasm_arch *arch, uintptr_t segreg, FILE *f); 
 
    /** Module-level implementation of yasm_arch_ea_create(). 
     * Call yasm_arch_ea_create() instead of calling this function. 
     */ 
    yasm_effaddr * (*ea_create) (yasm_arch *arch, /*@keep@*/ yasm_expr *e); 
 
    /** Module-level implementation of yasm_arch_ea_destroy(). 
     * Call yasm_arch_ea_destroy() instead of calling this function. 
     */ 
    void (*ea_destroy) (/*@only@*/ yasm_effaddr *ea); 
 
    /** Module-level implementation of yasm_arch_ea_print(). 
     * Call yasm_arch_ea_print() instead of calling this function. 
     */ 
    void (*ea_print) (const yasm_effaddr *ea, FILE *f, int indent_level); 
 
    /** Module-level implementation of yasm_arch_create_empty_insn(). 
     * Call yasm_arch_create_empty_insn() instead of calling this function. 
     */ 
    /*@only@*/ yasm_bytecode * (*create_empty_insn) (yasm_arch *arch, 
                                                     unsigned long line); 
 
    /** NULL-terminated list of machines for this architecture. 
     * Call yasm_arch_get_machine() to get the active machine of a particular 
     * #yasm_arch. 
     */ 
    const yasm_arch_machine *machines; 
 
    /** Default machine keyword. 
     * Call yasm_arch_get_machine() to get the active machine of a particular 
     * #yasm_arch. 
     */ 
    const char *default_machine_keyword; 
 
    /** Canonical "word" size in bits. 
     * Call yasm_arch_wordsize() to get the word size of a particular 
     * #yasm_arch. 
     */ 
    unsigned int wordsize; 
 
    /** Worst case minimum instruction length in bytes. 
     * Call yasm_arch_min_insn_len() to get the minimum instruction length of 
     * a particular #yasm_arch. 
     */ 
    unsigned int min_insn_len; 
} yasm_arch_module; 
 
/** Get the one-line description of an architecture. 
 * \param arch      architecture 
 * \return One-line description of architecture. 
 */ 
const char *yasm_arch_name(const yasm_arch *arch); 
 
/** Get the keyword used to select an architecture. 
 * \param arch      architecture 
 * \return Architecture keyword. 
 */ 
const char *yasm_arch_keyword(const yasm_arch *arch); 
 
/** Get the word size of an architecture. 
 * \param arch      architecture 
 * \return Word size (in bits). 
 */ 
unsigned int yasm_arch_wordsize(const yasm_arch *arch); 
 
/** Get the minimum instruction length of an architecture. 
 * \param arch      architecture 
 * \return Minimum instruction length (in bytes). 
 */ 
unsigned int yasm_arch_min_insn_len(const yasm_arch *arch); 
 
/** Create architecture. 
 * \param module        architecture module 
 * \param machine       keyword of machine in use (must be one listed in 
 *                      #yasm_arch_module.machines) 
 * \param parser        keyword of parser in use 
 * \param error         error return value 
 * \return NULL on error (error returned in error parameter), otherwise new 
 *         architecture. 
 */ 
/*@only@*/ yasm_arch *yasm_arch_create(const yasm_arch_module *module, 
                                       const char *machine, const char *parser, 
                                       /*@out@*/ yasm_arch_create_error *error); 
 
/** Clean up, free any architecture-allocated memory. 
 * \param arch  architecture 
 */ 
void yasm_arch_destroy(/*@only@*/ yasm_arch *arch); 
 
/** Get architecture's active machine name. 
 * \param arch  architecture 
 * \return Active machine name. 
 */ 
const char *yasm_arch_get_machine(const yasm_arch *arch); 
 
/** Get architecture's active address size, in bits. 
 * \param arch  architecture 
 * \return Active address size (in bits). 
 */ 
unsigned int yasm_arch_get_address_size(const yasm_arch *arch); 
 
/** Set any arch-specific variables.  For example, "mode_bits" in x86. 
 * \param arch  architecture 
 * \param var   variable name 
 * \param val   value to set 
 * \return Zero on success, non-zero on failure (variable does not exist). 
 */ 
int yasm_arch_set_var(yasm_arch *arch, const char *var, unsigned long val); 
 
/** Check an generic identifier to see if it matches architecture specific 
 * names for instructions or instruction prefixes.  Unrecognized identifiers 
 * should return #YASM_ARCH_NOTINSNPREFIX so they can be treated as normal 
 * symbols.  Any additional data beyond just the type (almost always necessary) 
 * should be returned into the space provided by the data parameter. 
 * \param arch          architecture 
 * \param id            identifier as in the input file 
 * \param id_len        length of id string 
 * \param line          virtual line 
 * \param bc            for instructions, yasm_insn-based bytecode is returned 
 *                      (and NULL otherwise) 
 * \param prefix        for prefixes, yasm_arch-specific value is returned 
 *                      (and 0 otherwise) 
 * \return Identifier type (#YASM_ARCH_NOTINSNPREFIX if unrecognized) 
 */ 
yasm_arch_insnprefix yasm_arch_parse_check_insnprefix 
    (yasm_arch *arch, const char *id, size_t id_len, unsigned long line, 
     /*@out@*/ /*@only@*/ yasm_bytecode **bc, /*@out@*/ uintptr_t *prefix); 
 
/** Check an generic identifier to see if it matches architecture specific 
 * names for registers or target modifiers.  Unrecognized identifiers should 
 * return #YASM_ARCH_NOTREGTMOD.  Any additional data beyond just the type 
 * (almost always necessary) should be returned into the space provided by the 
 * data parameter. 
 * \param arch          architecture 
 * \param id            identifier as in the input file 
 * \param id_len        length of id string 
 * \param data          extra identification information (yasm_arch-specific) 
 *                      [output] 
 * \return Identifier type (#YASM_ARCH_NOTREGTMOD if unrecognized) 
 */ 
yasm_arch_regtmod yasm_arch_parse_check_regtmod 
    (yasm_arch *arch, const char *id, size_t id_len, 
     /*@out@*/ uintptr_t *data); 
 
/** Get NOP fill patterns for 1-15 bytes of fill. 
 * \param arch          architecture 
 * \return 16-entry array of arrays; [0] is unused, [1] - [15] point to arrays 
 * of 1-15 bytes (respectively) in length. 
 */ 
const unsigned char **yasm_arch_get_fill(const yasm_arch *arch); 
 
/** Output #yasm_floatnum to buffer.  Puts the value into the least 
 * significant bits of the destination, or may be shifted into more 
 * significant bits by the shift parameter.  The destination bits are 
 * cleared before being set. 
 * Architecture-specific because of endianness. 
 * \param arch          architecture 
 * \param flt           floating point value 
 * \param buf           buffer to write into 
 * \param destsize      destination size (in bytes) 
 * \param valsize       size (in bits) 
 * \param shift         left shift (in bits) 
 * \param warn          enables standard overflow/underflow warnings 
 * \return Nonzero on error. 
 */ 
int yasm_arch_floatnum_tobytes(yasm_arch *arch, const yasm_floatnum *flt, 
                               unsigned char *buf, size_t destsize, 
                               size_t valsize, size_t shift, int warn); 
 
/** Output #yasm_intnum to buffer.  Puts the value into the least 
 * significant bits of the destination, or may be shifted into more 
 * significant bits by the shift parameter.  The destination bits are 
 * cleared before being set. 
 * \param arch          architecture 
 * \param intn          integer value 
 * \param buf           buffer to write into 
 * \param destsize      destination size (in bytes) 
 * \param valsize       size (in bits) 
 * \param shift         left shift (in bits); may be negative to specify right 
 *                      shift (standard warnings include truncation to boundary) 
 * \param bc            bytecode being output ("parent" of value) 
 * \param warn          enables standard warnings (value doesn't fit into 
 *                      valsize bits) 
 * \return Nonzero on error. 
 */ 
int yasm_arch_intnum_tobytes(yasm_arch *arch, const yasm_intnum *intn, 
                             unsigned char *buf, size_t destsize, 
                             size_t valsize, int shift, 
                             const yasm_bytecode *bc, int warn); 
 
/** Get the equivalent size of a register in bits. 
 * \param arch  architecture 
 * \param reg   register 
 * \return 0 if there is no suitable equivalent size, otherwise the size. 
 */ 
unsigned int yasm_arch_get_reg_size(yasm_arch *arch, uintptr_t reg); 
 
/** Get a specific register of a register group, based on the register 
 * group and the index within the group. 
 * \param arch          architecture 
 * \param reggroup      register group 
 * \param regindex      register index 
 * \return 0 if regindex is not valid for that register group, otherwise the 
 *         specific register value. 
 */ 
uintptr_t yasm_arch_reggroup_get_reg(yasm_arch *arch, uintptr_t reggroup, 
                                     unsigned long regindex); 
 
/** Print a register.  For debugging purposes. 
 * \param arch          architecture 
 * \param reg           register 
 * \param f             file 
 */ 
void yasm_arch_reg_print(yasm_arch *arch, uintptr_t reg, FILE *f); 
 
/** Print a segment register.  For debugging purposes. 
 * \param arch          architecture 
 * \param segreg        segment register 
 * \param f             file 
 */ 
void yasm_arch_segreg_print(yasm_arch *arch, uintptr_t segreg, FILE *f); 
 
/** Create an effective address from an expression. 
 * \param arch  architecture 
 * \param e     expression (kept, do not delete) 
 * \return Newly allocated effective address. 
 */ 
yasm_effaddr *yasm_arch_ea_create(yasm_arch *arch, /*@keep@*/ yasm_expr *e); 
 
/** Delete (free allocated memory for) an effective address. 
 * \param arch  architecture 
 * \param ea    effective address (only pointer to it). 
 */ 
void yasm_arch_ea_destroy(yasm_arch *arch, /*@only@*/ yasm_effaddr *ea); 
 
/** Print an effective address.  For debugging purposes. 
 * \param arch          architecture 
 * \param ea            effective address 
 * \param f             file 
 * \param indent_level  indentation level 
 */ 
void yasm_arch_ea_print(const yasm_arch *arch, const yasm_effaddr *ea, 
                        FILE *f, int indent_level); 
 
/** Create a bytecode that represents a single empty (0 length) instruction. 
 * This is used for handling solitary prefixes. 
 * \param arch          architecture 
 * \param line          virtual line (from yasm_linemap) 
 * \return Newly allocated bytecode. 
 */ 
/*@only@*/ yasm_bytecode *yasm_arch_create_empty_insn(yasm_arch *arch, 
                                                      unsigned long line); 
 
#ifndef YASM_DOXYGEN 
 
/* Inline macro implementations for arch functions */ 
 
#define yasm_arch_name(arch) \ 
    (((yasm_arch_base *)arch)->module->name) 
#define yasm_arch_keyword(arch) \ 
    (((yasm_arch_base *)arch)->module->keyword) 
#define yasm_arch_wordsize(arch) \ 
    (((yasm_arch_base *)arch)->module->wordsize) 
#define yasm_arch_min_insn_len(arch) \ 
    (((yasm_arch_base *)arch)->module->min_insn_len) 
 
#define yasm_arch_create(module, machine, parser, error) \ 
    module->create(machine, parser, error) 
 
#define yasm_arch_destroy(arch) \ 
    ((yasm_arch_base *)arch)->module->destroy(arch) 
#define yasm_arch_get_machine(arch) \ 
    ((yasm_arch_base *)arch)->module->get_machine(arch) 
#define yasm_arch_get_address_size(arch) \ 
    ((yasm_arch_base *)arch)->module->get_address_size(arch) 
#define yasm_arch_set_var(arch, var, val) \ 
    ((yasm_arch_base *)arch)->module->set_var(arch, var, val) 
#define yasm_arch_parse_check_insnprefix(arch, id, id_len, line, bc, prefix) \ 
    ((yasm_arch_base *)arch)->module->parse_check_insnprefix \ 
        (arch, id, id_len, line, bc, prefix) 
#define yasm_arch_parse_check_regtmod(arch, id, id_len, data) \ 
    ((yasm_arch_base *)arch)->module->parse_check_regtmod \ 
        (arch, id, id_len, data) 
#define yasm_arch_get_fill(arch) \ 
    ((yasm_arch_base *)arch)->module->get_fill(arch) 
#define yasm_arch_floatnum_tobytes(arch, flt, buf, destsize, valsize, shift, \ 
                                   warn) \ 
    ((yasm_arch_base *)arch)->module->floatnum_tobytes \ 
        (arch, flt, buf, destsize, valsize, shift, warn) 
#define yasm_arch_intnum_tobytes(arch, intn, buf, destsize, valsize, shift, \ 
                                 bc, warn) \ 
    ((yasm_arch_base *)arch)->module->intnum_tobytes \ 
        (arch, intn, buf, destsize, valsize, shift, bc, warn) 
#define yasm_arch_get_reg_size(arch, reg) \ 
    ((yasm_arch_base *)arch)->module->get_reg_size(arch, reg) 
#define yasm_arch_reggroup_get_reg(arch, regg, regi) \ 
    ((yasm_arch_base *)arch)->module->reggroup_get_reg(arch, regg, regi) 
#define yasm_arch_reg_print(arch, reg, f) \ 
    ((yasm_arch_base *)arch)->module->reg_print(arch, reg, f) 
#define yasm_arch_segreg_print(arch, segreg, f) \ 
    ((yasm_arch_base *)arch)->module->segreg_print(arch, segreg, f) 
#define yasm_arch_ea_create(arch, e) \ 
    ((yasm_arch_base *)arch)->module->ea_create(arch, e) 
#define yasm_arch_ea_destroy(arch, ea) \ 
    ((yasm_arch_base *)arch)->module->ea_destroy(ea) 
#define yasm_arch_ea_print(arch, ea, f, i) \ 
    ((yasm_arch_base *)arch)->module->ea_print(ea, f, i) 
#define yasm_arch_create_empty_insn(arch, line) \ 
    ((yasm_arch_base *)arch)->module->create_empty_insn(arch, line) 
 
#endif 
 
#endif