target/hexagon/idef-parser/idef-parser.h

   1 /*
   2  *  Copyright(c) 2019-2022 rev.ng Labs Srl. All Rights Reserved.
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifndef IDEF_PARSER_H
  19 #define IDEF_PARSER_H
  20
  21 #include <inttypes.h>
  22 #include <stdio.h>
  23 #include <stdbool.h>
  24 #include <glib.h>
  25
  26 #define TCGV_NAME_SIZE 7
  27 #define MAX_WRITTEN_REGS 32
  28 #define OFFSET_STR_LEN 32
  29 #define ALLOC_LIST_LEN 32
  30 #define ALLOC_NAME_SIZE 32
  31 #define INIT_LIST_LEN 32
  32 #define OUT_BUF_LEN (1024 * 1024)
  33 #define SIGNATURE_BUF_LEN (128 * 1024)
  34 #define HEADER_BUF_LEN (128 * 1024)
  35
  36 /* Variadic macros to wrap the buffer printing functions */
  37 #define EMIT(c, ...)                                                           \
  38     do {                                                                       \
  39         g_string_append_printf((c)->out_str, __VA_ARGS__);                     \
  40     } while (0)
  41
  42 #define EMIT_SIG(c, ...)                                                       \
  43     do {                                                                       \
  44         g_string_append_printf((c)->signature_str, __VA_ARGS__);               \
  45     } while (0)
  46
  47 #define EMIT_HEAD(c, ...)                                                      \
  48     do {                                                                       \
  49         g_string_append_printf((c)->header_str, __VA_ARGS__);                  \
  50     } while (0)
  51
  52 /**
  53  * Type of register, assigned to the HexReg.type field
  54  */
  55 typedef enum { GENERAL_PURPOSE, CONTROL, MODIFIER, DOTNEW } HexRegType;
  56
  57 typedef enum { UNKNOWN_SIGNEDNESS, SIGNED, UNSIGNED } HexSignedness;
  58
  59 /**
  60  * Semantic record of the REG tokens, identifying registers
  61  */
  62 typedef struct HexReg {
  63     uint8_t id;                 /**< Identifier of the register               */
  64     HexRegType type;            /**< Type of the register                     */
  65     unsigned bit_width;         /**< Bit width of the reg, 32 or 64 bits      */
  66 } HexReg;
  67
  68 /**
  69  * Data structure, identifying a TCGv temporary value
  70  */
  71 typedef struct HexTmp {
  72     unsigned index;             /**< Index of the TCGv temporary value        */
  73 } HexTmp;
  74
  75 /**
  76  * Enum of the possible immediate, an immediate is a value which is known
  77  * at tinycode generation time, e.g. an integer value, not a TCGv
  78  */
  79 enum ImmUnionTag {
  80     I,
  81     VARIABLE,
  82     VALUE,
  83     QEMU_TMP,
  84     IMM_PC,
  85     IMM_CONSTEXT,
  86 };
  87
  88 /**
  89  * Semantic record of the IMM token, identifying an immediate constant
  90  */
  91 typedef struct HexImm {
  92     union {
  93         char id;                /**< Identifier, used when type is VARIABLE   */
  94         uint64_t value;         /**< Immediate value, used when type is VALUE */
  95         uint64_t index;         /**< Index, used when type is QEMU_TMP        */
  96     };
  97     enum ImmUnionTag type;      /**< Type of the immediate                    */
  98 } HexImm;
  99
 100 /**
 101  * Semantic record of the PRED token, identifying a predicate
 102  */
 103 typedef struct HexPred {
 104     char id;                    /**< Identifier of the predicate              */
 105 } HexPred;
 106
 107 /**
 108  * Semantic record of the SAT token, identifying the saturate operator
 109  * Note: All saturates are assumed to implicitly set overflow.
 110  */
 111 typedef struct HexSat {
 112     HexSignedness signedness;   /**< Signedness of the sat. op.               */
 113 } HexSat;
 114
 115 /**
 116  * Semantic record of the CAST token, identifying the cast operator
 117  */
 118 typedef struct HexCast {
 119     unsigned bit_width;         /**< Bit width of the cast operator           */
 120     HexSignedness signedness;   /**< Unsigned flag for the cast operator      */
 121 } HexCast;
 122
 123 /**
 124  * Semantic record of the EXTRACT token, identifying the cast operator
 125  */
 126 typedef struct HexExtract {
 127     unsigned bit_width;         /**< Bit width of the extract operator        */
 128     unsigned storage_bit_width; /**< Actual bit width of the extract operator */
 129     HexSignedness signedness;   /**< Unsigned flag for the extract operator   */
 130 } HexExtract;
 131
 132 /**
 133  * Semantic record of the MPY token, identifying the fMPY multiplication
 134  * operator
 135  */
 136 typedef struct HexMpy {
 137     unsigned first_bit_width;        /**< Bit width of 1st operand of fMPY    */
 138     unsigned second_bit_width;       /**< Bit width of 2nd operand of fMPY    */
 139     HexSignedness first_signedness;  /**< Signedness of 1st operand of fMPY   */
 140     HexSignedness second_signedness; /**< Signedness of 2nd operand of fMPY   */
 141 } HexMpy;
 142
 143 /**
 144  * Semantic record of the VARID token, identifying declared variables
 145  * of the input language
 146  */
 147 typedef struct HexVar {
 148     GString *name;              /**< Name of the VARID variable               */
 149 } HexVar;
 150
 151 /**
 152  * Data structure uniquely identifying a declared VARID variable, used for
 153  * keeping track of declared variable, so that any variable is declared only
 154  * once, and its properties are propagated through all the subsequent instances
 155  * of that variable
 156  */
 157 typedef struct Var {
 158     GString *name;              /**< Name of the VARID variable               */
 159     uint8_t bit_width;          /**< Bit width of the VARID variable          */
 160     HexSignedness signedness;   /**< Unsigned flag for the VARID var          */
 161 } Var;
 162
 163 /**
 164  * Enum of the possible rvalue types, used in the HexValue.type field
 165  */
 166 typedef enum RvalueUnionTag {
 167     REGISTER, REGISTER_ARG, TEMP, IMMEDIATE, PREDICATE, VARID
 168 } RvalueUnionTag;
 169
 170 /**
 171  * Semantic record of the rvalue token, identifying any numeric value,
 172  * immediate or register based. The rvalue tokens are combined together
 173  * through the use of several operators, to encode expressions
 174  */
 175 typedef struct HexValue {
 176     union {
 177         HexReg reg;             /**< rvalue of register type                  */
 178         HexTmp tmp;             /**< rvalue of temporary type                 */
 179         HexImm imm;             /**< rvalue of immediate type                 */
 180         HexPred pred;           /**< rvalue of predicate type                 */
 181         HexVar var;             /**< rvalue of declared variable type         */
 182     };
 183     RvalueUnionTag type;        /**< Type of the rvalue                       */
 184     unsigned bit_width;         /**< Bit width of the rvalue                  */
 185     HexSignedness signedness;   /**< Unsigned flag for the rvalue             */
 186     bool is_dotnew;             /**< rvalue of predicate type is dotnew?      */
 187 } HexValue;
 188
 189 /**
 190  * State of ternary operator
 191  */
 192 typedef enum TernaryState { IN_LEFT, IN_RIGHT } TernaryState;
 193
 194 /**
 195  * Data structure used to handle side effects inside ternary operators
 196  */
 197 typedef struct Ternary {
 198     TernaryState state;
 199     HexValue cond;
 200 } Ternary;
 201
 202 /**
 203  * Operator type, used for referencing the correct operator when calling the
 204  * gen_bin_op() function, which in turn will generate the correct code to
 205  * execute the operation between the two rvalues
 206  */
 207 typedef enum OpType {
 208     ADD_OP, SUB_OP, MUL_OP, ASL_OP, ASR_OP, LSR_OP, ANDB_OP, ORB_OP,
 209     XORB_OP, ANDL_OP, MINI_OP, MAXI_OP
 210 } OpType;
 211
 212 /**
 213  * Data structure including instruction specific information, to be cleared
 214  * out after the compilation of each instruction
 215  */
 216 typedef struct Inst {
 217     GString *name;              /**< Name of the compiled instruction         */
 218     char *code_begin;           /**< Beginning of instruction input code      */
 219     char *code_end;             /**< End of instruction input code            */
 220     unsigned tmp_count;         /**< Index of the last declared TCGv temp     */
 221     unsigned qemu_tmp_count;    /**< Index of the last declared int temp      */
 222     unsigned if_count;          /**< Index of the last declared if label      */
 223     unsigned error_count;       /**< Number of generated errors               */
 224     GArray *allocated;          /**< Allocated declaredVARID vars             */
 225     GArray *init_list;          /**< List of initialized registers            */
 226     GArray *strings;            /**< Strings allocated by the instruction     */
 227 } Inst;
 228
 229 /**
 230  * Data structure representing the whole translation context, which in a
 231  * reentrant flex/bison parser just like ours is passed between the scanner
 232  * and the parser, holding all the necessary information to perform the
 233  * parsing, this data structure survives between the compilation of different
 234  * instructions
 235  */
 236 typedef struct Context {
 237     void *scanner;              /**< Reentrant parser state pointer           */
 238     char *input_buffer;         /**< Buffer containing the input code         */
 239     GString *out_str;           /**< String containing the output code        */
 240     GString *signature_str;     /**< String containing the signatures code    */
 241     GString *header_str;        /**< String containing the header code        */
 242     FILE *defines_file;         /**< FILE * of the generated header           */
 243     FILE *output_file;          /**< FILE * of the C output file              */
 244     FILE *enabled_file;         /**< FILE * of the list of enabled inst       */
 245     GArray *ternary;            /**< Array to track nesting of ternary ops    */
 246     unsigned total_insn;        /**< Number of instructions in input file     */
 247     unsigned implemented_insn;  /**< Instruction compiled without errors      */
 248     Inst inst;                  /**< Parsing data of the current inst         */
 249 } Context;
 250
 251 #endif /* IDEF_PARSER_H */