1  /* mips-formats.h
       2     Copyright (C) 2013-2023 Free Software Foundation, Inc.
       3  
       4     This library 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 3, or (at your option)
       7     any later version.
       8  
       9     It is distributed in the hope that it will be useful, but WITHOUT
      10     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
      11     or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
      12     License for more details.
      13  
      14     You should have received a copy of the GNU General Public License
      15     along with this program; see the file COPYING3. If not,
      16     see <http://www.gnu.org/licenses/>.  */
      17  
      18  /* For ARRAY_SIZE.  */
      19  #include "libiberty.h"
      20  
      21  #define INT_BIAS(SIZE, LSB, MAX_VAL, BIAS, SHIFT, PRINT_HEX) \
      22    { \
      23      static const struct mips_int_operand op = { \
      24        { OP_INT, SIZE, LSB }, MAX_VAL, BIAS, SHIFT, PRINT_HEX \
      25      }; \
      26      return &op.root; \
      27    }
      28  
      29  #define INT_ADJ(SIZE, LSB, MAX_VAL, SHIFT, PRINT_HEX) \
      30    INT_BIAS(SIZE, LSB, MAX_VAL, 0, SHIFT, PRINT_HEX)
      31  
      32  #define UINT(SIZE, LSB) \
      33    INT_ADJ(SIZE, LSB, (1 << (SIZE)) - 1, 0, false)
      34  
      35  #define SINT(SIZE, LSB) \
      36    INT_ADJ(SIZE, LSB, (1 << ((SIZE) - 1)) - 1, 0, false)
      37  
      38  #define HINT(SIZE, LSB) \
      39    INT_ADJ(SIZE, LSB, (1 << (SIZE)) - 1, 0, true)
      40  
      41  #define BIT(SIZE, LSB, BIAS) \
      42    { \
      43      static const struct mips_int_operand op = { \
      44        { OP_INT, SIZE, LSB }, (1 << (SIZE)) - 1, BIAS, 0, true \
      45      }; \
      46      return &op.root; \
      47    }
      48  
      49  #define MAPPED_INT(SIZE, LSB, MAP, PRINT_HEX) \
      50    { \
      51      typedef char ATTRIBUTE_UNUSED \
      52        static_assert[(1 << (SIZE)) == ARRAY_SIZE (MAP)]; \
      53      static const struct mips_mapped_int_operand op = { \
      54        { OP_MAPPED_INT, SIZE, LSB }, MAP, PRINT_HEX \
      55      }; \
      56      return &op.root; \
      57    }
      58  
      59  #define MSB(SIZE, LSB, BIAS, ADD_LSB, OPSIZE) \
      60    { \
      61      static const struct mips_msb_operand op = { \
      62        { OP_MSB, SIZE, LSB }, BIAS, ADD_LSB, OPSIZE \
      63      }; \
      64      return &op.root; \
      65    }
      66  
      67  #define REG(SIZE, LSB, BANK) \
      68    { \
      69      static const struct mips_reg_operand op = { \
      70        { OP_REG, SIZE, LSB }, OP_REG_##BANK, 0 \
      71      }; \
      72      return &op.root; \
      73    }
      74  
      75  #define OPTIONAL_REG(SIZE, LSB, BANK) \
      76    { \
      77      static const struct mips_reg_operand op = { \
      78        { OP_OPTIONAL_REG, SIZE, LSB }, OP_REG_##BANK, 0 \
      79      }; \
      80      return &op.root; \
      81    }
      82  
      83  #define MAPPED_REG(SIZE, LSB, BANK, MAP) \
      84    { \
      85      typedef char ATTRIBUTE_UNUSED \
      86        static_assert[(1 << (SIZE)) == ARRAY_SIZE (MAP)]; \
      87      static const struct mips_reg_operand op = { \
      88        { OP_REG, SIZE, LSB }, OP_REG_##BANK, MAP \
      89      }; \
      90      return &op.root; \
      91    }
      92  
      93  #define OPTIONAL_MAPPED_REG(SIZE, LSB, BANK, MAP) \
      94    { \
      95      typedef char ATTRIBUTE_UNUSED \
      96        static_assert[(1 << (SIZE)) == ARRAY_SIZE (MAP)]; \
      97      static const struct mips_reg_operand op = { \
      98        { OP_OPTIONAL_REG, SIZE, LSB }, OP_REG_##BANK, MAP \
      99      }; \
     100      return &op.root; \
     101    }
     102  
     103  #define REG_PAIR(SIZE, LSB, BANK, MAP) \
     104    { \
     105      typedef char ATTRIBUTE_UNUSED \
     106        static_assert1[(1 << (SIZE)) == ARRAY_SIZE (MAP##1)]; \
     107      typedef char ATTRIBUTE_UNUSED \
     108        static_assert2[(1 << (SIZE)) == ARRAY_SIZE (MAP##2)]; \
     109      static const struct mips_reg_pair_operand op = { \
     110        { OP_REG_PAIR, SIZE, LSB }, OP_REG_##BANK, MAP##1, MAP##2 \
     111      }; \
     112      return &op.root; \
     113    }
     114  
     115  #define PCREL(SIZE, LSB, IS_SIGNED, SHIFT, ALIGN_LOG2, INCLUDE_ISA_BIT, \
     116                FLIP_ISA_BIT) \
     117    { \
     118      static const struct mips_pcrel_operand op = { \
     119        { { OP_PCREL, SIZE, LSB }, \
     120  	(1 << ((SIZE) - (IS_SIGNED))) - 1, 0, SHIFT, true }, \
     121        ALIGN_LOG2, INCLUDE_ISA_BIT, FLIP_ISA_BIT \
     122      }; \
     123      return &op.root.root; \
     124    }
     125  
     126  #define JUMP(SIZE, LSB, SHIFT) \
     127    PCREL (SIZE, LSB, false, SHIFT, SIZE + SHIFT, true, false)
     128  
     129  #define JALX(SIZE, LSB, SHIFT) \
     130    PCREL (SIZE, LSB, false, SHIFT, SIZE + SHIFT, true, true)
     131  
     132  #define BRANCH(SIZE, LSB, SHIFT) \
     133    PCREL (SIZE, LSB, true, SHIFT, 0, true, false)
     134  
     135  #define SPECIAL(SIZE, LSB, TYPE) \
     136    { \
     137      static const struct mips_operand op = { OP_##TYPE, SIZE, LSB }; \
     138      return &op; \
     139    }
     140  
     141  #define PREV_CHECK(SIZE, LSB, GT_OK, LT_OK, EQ_OK, ZERO_OK) \
     142    { \
     143      static const struct mips_check_prev_operand op = { \
     144        { OP_CHECK_PREV, SIZE, LSB }, GT_OK, LT_OK, EQ_OK, ZERO_OK \
     145      }; \
     146      return &op.root; \
     147    }