1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Generate opcode table initializers for the in-kernel disassembler.
4  *
5  *    Copyright IBM Corp. 2017
6  *
7  */
8 
9 #include <stdlib.h>
10 #include <string.h>
11 #include <ctype.h>
12 #include <stdio.h>
13 
14 #define STRING_SIZE_MAX 20
15 
16 struct insn_type {
17 	unsigned char byte;
18 	unsigned char mask;
19 	char **format;
20 };
21 
22 struct insn {
23 	struct insn_type *type;
24 	char opcode[STRING_SIZE_MAX];
25 	char name[STRING_SIZE_MAX];
26 	char upper[STRING_SIZE_MAX];
27 	char format[STRING_SIZE_MAX];
28 	unsigned int name_len;
29 };
30 
31 struct insn_group {
32 	struct insn_type *type;
33 	int offset;
34 	int count;
35 	char opcode[2];
36 };
37 
38 struct insn_format {
39 	char *format;
40 	int type;
41 };
42 
43 struct gen_opcode {
44 	struct insn *insn;
45 	int nr;
46 	struct insn_group *group;
47 	int nr_groups;
48 };
49 
50 /*
51  * Table of instruction format types. Each opcode is defined with at
52  * least one byte (two nibbles), three nibbles, or two bytes (four
53  * nibbles).
54  * The byte member of each instruction format type entry defines
55  * within which byte of an instruction the third (and fourth) nibble
56  * of an opcode can be found. The mask member is the and-mask that
57  * needs to be applied on this byte in order to get the third (and
58  * fourth) nibble of the opcode.
59  * The format array defines all instruction formats (as defined in the
60  * Principles of Operation) which have the same position of the opcode
61  * nibbles.
62  * A special case are instruction formats with 1-byte opcodes. In this
63  * case the byte member always is zero, so that the mask is applied on
64  * the (only) byte that contains the opcode.
65  */
66 static struct insn_type insn_type_table[] = {
67 	{
68 		.byte = 0,
69 		.mask = 0xff,
70 		.format = (char *[]) {
71 			"MII",
72 			"RR",
73 			"RS",
74 			"RSI",
75 			"RX",
76 			"SI",
77 			"SMI",
78 			"SS",
79 			NULL,
80 		},
81 	},
82 	{
83 		.byte = 1,
84 		.mask = 0x0f,
85 		.format = (char *[]) {
86 			"RI",
87 			"RIL",
88 			"SSF",
89 			NULL,
90 		},
91 	},
92 	{
93 		.byte = 1,
94 		.mask = 0xff,
95 		.format = (char *[]) {
96 			"E",
97 			"IE",
98 			"RRE",
99 			"RRF",
100 			"RRR",
101 			"S",
102 			"SIL",
103 			"SSE",
104 			NULL,
105 		},
106 	},
107 	{
108 		.byte = 5,
109 		.mask = 0xff,
110 		.format = (char *[]) {
111 			"RIE",
112 			"RIS",
113 			"RRS",
114 			"RSE",
115 			"RSL",
116 			"RSY",
117 			"RXE",
118 			"RXF",
119 			"RXY",
120 			"SIY",
121 			"VRI",
122 			"VRR",
123 			"VRS",
124 			"VRV",
125 			"VRX",
126 			"VSI",
127 			NULL,
128 		},
129 	},
130 };
131 
132 static struct insn_type *insn_format_to_type(char *format)
133 {
134 	char tmp[STRING_SIZE_MAX];
135 	char *base_format, **ptr;
136 	int i;
137 
138 	strcpy(tmp, format);
139 	base_format = tmp;
140 	base_format = strsep(&base_format, "_");
141 	for (i = 0; i < sizeof(insn_type_table) / sizeof(insn_type_table[0]); i++) {
142 		ptr = insn_type_table[i].format;
143 		while (*ptr) {
144 			if (!strcmp(base_format, *ptr))
145 				return &insn_type_table[i];
146 			ptr++;
147 		}
148 	}
149 	exit(EXIT_FAILURE);
150 }
151 
152 static void read_instructions(struct gen_opcode *desc)
153 {
154 	struct insn insn;
155 	int rc, i;
156 
157 	while (1) {
158 		rc = scanf("%s %s %s", insn.opcode, insn.name, insn.format);
159 		if (rc == EOF)
160 			break;
161 		if (rc != 3)
162 			exit(EXIT_FAILURE);
163 		insn.type = insn_format_to_type(insn.format);
164 		insn.name_len = strlen(insn.name);
165 		for (i = 0; i <= insn.name_len; i++)
166 			insn.upper[i] = toupper((unsigned char)insn.name[i]);
167 		desc->nr++;
168 		desc->insn = realloc(desc->insn, desc->nr * sizeof(*desc->insn));
169 		if (!desc->insn)
170 			exit(EXIT_FAILURE);
171 		desc->insn[desc->nr - 1] = insn;
172 	}
173 }
174 
175 static int cmpformat(const void *a, const void *b)
176 {
177 	return strcmp(((struct insn *)a)->format, ((struct insn *)b)->format);
178 }
179 
180 static void print_formats(struct gen_opcode *desc)
181 {
182 	char *format;
183 	int i, count;
184 
185 	qsort(desc->insn, desc->nr, sizeof(*desc->insn), cmpformat);
186 	format = "";
187 	count = 0;
188 	printf("enum {\n");
189 	for (i = 0; i < desc->nr; i++) {
190 		if (!strcmp(format, desc->insn[i].format))
191 			continue;
192 		count++;
193 		format = desc->insn[i].format;
194 		printf("\tINSTR_%s,\n", format);
195 	}
196 	printf("}; /* %d */\n\n", count);
197 }
198 
199 static int cmp_long_insn(const void *a, const void *b)
200 {
201 	return strcmp(((struct insn *)a)->name, ((struct insn *)b)->name);
202 }
203 
204 static void print_long_insn(struct gen_opcode *desc)
205 {
206 	struct insn *insn;
207 	int i, count;
208 
209 	qsort(desc->insn, desc->nr, sizeof(*desc->insn), cmp_long_insn);
210 	count = 0;
211 	printf("enum {\n");
212 	for (i = 0; i < desc->nr; i++) {
213 		insn = &desc->insn[i];
214 		if (insn->name_len < 6)
215 			continue;
216 		printf("\tLONG_INSN_%s,\n", insn->upper);
217 		count++;
218 	}
219 	printf("}; /* %d */\n\n", count);
220 
221 	printf("#define LONG_INSN_INITIALIZER { \\\n");
222 	for (i = 0; i < desc->nr; i++) {
223 		insn = &desc->insn[i];
224 		if (insn->name_len < 6)
225 			continue;
226 		printf("\t[LONG_INSN_%s] = \"%s\", \\\n", insn->upper, insn->name);
227 	}
228 	printf("}\n\n");
229 }
230 
231 static void print_opcode(struct insn *insn, int nr)
232 {
233 	char *opcode;
234 
235 	opcode = insn->opcode;
236 	if (insn->type->byte != 0)
237 		opcode += 2;
238 	printf("\t[%4d] = { .opfrag = 0x%s, .format = INSTR_%s, ", nr, opcode, insn->format);
239 	if (insn->name_len < 6)
240 		printf(".name = \"%s\" ", insn->name);
241 	else
242 		printf(".offset = LONG_INSN_%s ", insn->upper);
243 	printf("}, \\\n");
244 }
245 
246 static void add_to_group(struct gen_opcode *desc, struct insn *insn, int offset)
247 {
248 	struct insn_group *group;
249 
250 	group = desc->group ? &desc->group[desc->nr_groups - 1] : NULL;
251 	if (group && (!strncmp(group->opcode, insn->opcode, 2) || group->type->byte == 0)) {
252 		group->count++;
253 		return;
254 	}
255 	desc->nr_groups++;
256 	desc->group = realloc(desc->group, desc->nr_groups * sizeof(*desc->group));
257 	if (!desc->group)
258 		exit(EXIT_FAILURE);
259 	group = &desc->group[desc->nr_groups - 1];
260 	memcpy(group->opcode, insn->opcode, 2);
261 	group->type = insn->type;
262 	group->offset = offset;
263 	group->count = 1;
264 }
265 
266 static int cmpopcode(const void *a, const void *b)
267 {
268 	return strcmp(((struct insn *)a)->opcode, ((struct insn *)b)->opcode);
269 }
270 
271 static void print_opcode_table(struct gen_opcode *desc)
272 {
273 	char opcode[2] = "";
274 	struct insn *insn;
275 	int i, offset;
276 
277 	qsort(desc->insn, desc->nr, sizeof(*desc->insn), cmpopcode);
278 	printf("#define OPCODE_TABLE_INITIALIZER { \\\n");
279 	offset = 0;
280 	for (i = 0; i < desc->nr; i++) {
281 		insn = &desc->insn[i];
282 		if (insn->type->byte == 0)
283 			continue;
284 		add_to_group(desc, insn, offset);
285 		if (strncmp(opcode, insn->opcode, 2)) {
286 			memcpy(opcode, insn->opcode, 2);
287 			printf("\t/* %.2s */ \\\n", opcode);
288 		}
289 		print_opcode(insn, offset);
290 		offset++;
291 	}
292 	printf("\t/* 1-byte opcode instructions */ \\\n");
293 	for (i = 0; i < desc->nr; i++) {
294 		insn = &desc->insn[i];
295 		if (insn->type->byte != 0)
296 			continue;
297 		add_to_group(desc, insn, offset);
298 		print_opcode(insn, offset);
299 		offset++;
300 	}
301 	printf("}\n\n");
302 }
303 
304 static void print_opcode_table_offsets(struct gen_opcode *desc)
305 {
306 	struct insn_group *group;
307 	int i;
308 
309 	printf("#define OPCODE_OFFSET_INITIALIZER { \\\n");
310 	for (i = 0; i < desc->nr_groups; i++) {
311 		group = &desc->group[i];
312 		printf("\t{ .opcode = 0x%.2s, .mask = 0x%02x, .byte = %d, .offset = %d, .count = %d }, \\\n",
313 		       group->opcode, group->type->mask, group->type->byte, group->offset, group->count);
314 	}
315 	printf("}\n\n");
316 }
317 
318 int main(int argc, char **argv)
319 {
320 	struct gen_opcode _desc = { 0 };
321 	struct gen_opcode *desc = &_desc;
322 
323 	read_instructions(desc);
324 	printf("#ifndef __S390_GENERATED_DIS_DEFS_H__\n");
325 	printf("#define __S390_GENERATED_DIS_DEFS_H__\n");
326 	printf("/*\n");
327 	printf(" * DO NOT MODIFY.\n");
328 	printf(" *\n");
329 	printf(" * This file was generated by %s\n", __FILE__);
330 	printf(" */\n\n");
331 	print_formats(desc);
332 	print_long_insn(desc);
333 	print_opcode_table(desc);
334 	print_opcode_table_offsets(desc);
335 	printf("#endif\n");
336 	exit(EXIT_SUCCESS);
337 }
338