1 /* mips-formats.h
2    Copyright (C) 2013-2016 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_ADJ(SIZE, LSB, MAX_VAL, SHIFT, PRINT_HEX) \
22   { \
23     static const struct mips_int_operand op = { \
24       { OP_INT, SIZE, LSB }, MAX_VAL, 0, SHIFT, PRINT_HEX \
25     }; \
26     return &op.root; \
27   }
28 
29 #define UINT(SIZE, LSB) \
30   INT_ADJ(SIZE, LSB, (1 << (SIZE)) - 1, 0, FALSE)
31 
32 #define SINT(SIZE, LSB) \
33   INT_ADJ(SIZE, LSB, (1 << ((SIZE) - 1)) - 1, 0, FALSE)
34 
35 #define HINT(SIZE, LSB) \
36   INT_ADJ(SIZE, LSB, (1 << (SIZE)) - 1, 0, TRUE)
37 
38 #define BIT(SIZE, LSB, BIAS) \
39   { \
40     static const struct mips_int_operand op = { \
41       { OP_INT, SIZE, LSB }, (1 << (SIZE)) - 1, BIAS, 0, TRUE \
42     }; \
43     return &op.root; \
44   }
45 
46 #define MAPPED_INT(SIZE, LSB, MAP, PRINT_HEX) \
47   { \
48     typedef char ATTRIBUTE_UNUSED \
49       static_assert[(1 << (SIZE)) == ARRAY_SIZE (MAP)]; \
50     static const struct mips_mapped_int_operand op = { \
51       { OP_MAPPED_INT, SIZE, LSB }, MAP, PRINT_HEX \
52     }; \
53     return &op.root; \
54   }
55 
56 #define MSB(SIZE, LSB, BIAS, ADD_LSB, OPSIZE) \
57   { \
58     static const struct mips_msb_operand op = { \
59       { OP_MSB, SIZE, LSB }, BIAS, ADD_LSB, OPSIZE \
60     }; \
61     return &op.root; \
62   }
63 
64 #define REG(SIZE, LSB, BANK) \
65   { \
66     static const struct mips_reg_operand op = { \
67       { OP_REG, SIZE, LSB }, OP_REG_##BANK, 0 \
68     }; \
69     return &op.root; \
70   }
71 
72 #define OPTIONAL_REG(SIZE, LSB, BANK) \
73   { \
74     static const struct mips_reg_operand op = { \
75       { OP_OPTIONAL_REG, SIZE, LSB }, OP_REG_##BANK, 0 \
76     }; \
77     return &op.root; \
78   }
79 
80 #define MAPPED_REG(SIZE, LSB, BANK, MAP) \
81   { \
82     typedef char ATTRIBUTE_UNUSED \
83       static_assert[(1 << (SIZE)) == ARRAY_SIZE (MAP)]; \
84     static const struct mips_reg_operand op = { \
85       { OP_REG, SIZE, LSB }, OP_REG_##BANK, MAP \
86     }; \
87     return &op.root; \
88   }
89 
90 #define OPTIONAL_MAPPED_REG(SIZE, LSB, BANK, MAP) \
91   { \
92     typedef char ATTRIBUTE_UNUSED \
93       static_assert[(1 << (SIZE)) == ARRAY_SIZE (MAP)]; \
94     static const struct mips_reg_operand op = { \
95       { OP_OPTIONAL_REG, SIZE, LSB }, OP_REG_##BANK, MAP \
96     }; \
97     return &op.root; \
98   }
99 
100 #define REG_PAIR(SIZE, LSB, BANK, MAP) \
101   { \
102     typedef char ATTRIBUTE_UNUSED \
103       static_assert1[(1 << (SIZE)) == ARRAY_SIZE (MAP##1)]; \
104     typedef char ATTRIBUTE_UNUSED \
105       static_assert2[(1 << (SIZE)) == ARRAY_SIZE (MAP##2)]; \
106     static const struct mips_reg_pair_operand op = { \
107       { OP_REG_PAIR, SIZE, LSB }, OP_REG_##BANK, MAP##1, MAP##2 \
108     }; \
109     return &op.root; \
110   }
111 
112 #define PCREL(SIZE, LSB, IS_SIGNED, SHIFT, ALIGN_LOG2, INCLUDE_ISA_BIT, \
113               FLIP_ISA_BIT) \
114   { \
115     static const struct mips_pcrel_operand op = { \
116       { { OP_PCREL, SIZE, LSB }, \
117 	(1 << ((SIZE) - (IS_SIGNED))) - 1, 0, SHIFT, TRUE }, \
118       ALIGN_LOG2, INCLUDE_ISA_BIT, FLIP_ISA_BIT \
119     }; \
120     return &op.root.root; \
121   }
122 
123 #define JUMP(SIZE, LSB, SHIFT) \
124   PCREL (SIZE, LSB, FALSE, SHIFT, SIZE + SHIFT, TRUE, FALSE)
125 
126 #define JALX(SIZE, LSB, SHIFT) \
127   PCREL (SIZE, LSB, FALSE, SHIFT, SIZE + SHIFT, TRUE, TRUE)
128 
129 #define BRANCH(SIZE, LSB, SHIFT) \
130   PCREL (SIZE, LSB, TRUE, SHIFT, 0, TRUE, FALSE)
131 
132 #define SPECIAL(SIZE, LSB, TYPE) \
133   { \
134     static const struct mips_operand op = { OP_##TYPE, SIZE, LSB }; \
135     return &op; \
136   }
137 
138 #define PREV_CHECK(SIZE, LSB, GT_OK, LT_OK, EQ_OK, ZERO_OK) \
139   { \
140     static const struct mips_check_prev_operand op = { \
141       { OP_CHECK_PREV, SIZE, LSB }, GT_OK, LT_OK, EQ_OK, ZERO_OK \
142     }; \
143     return &op.root; \
144   }
145