notaz.gp2x.de / picodrive.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
32x, take over sh2 cycles setting in-game
[picodrive.git] / cpu / musashi / m68kmake.c
... / ...
CommitLineData
1/* ======================================================================== */\r
2/* ========================= LICENSING & COPYRIGHT ======================== */\r
3/* ======================================================================== */\r
4/*\r
5 * MUSASHI\r
6 * Version 3.31\r
7 *\r
8 * A portable Motorola M680x0 processor emulation engine.\r
9 * Copyright 1998-2007 Karl Stenerud. All rights reserved.\r
10 *\r
11 * This code may be freely used for non-commercial purposes as long as this\r
12 * copyright notice remains unaltered in the source code and any binary files\r
13 * containing this code in compiled form.\r
14 *\r
15 * All other lisencing terms must be negotiated with the author\r
16 * (Karl Stenerud).\r
17 *\r
18 * The latest version of this code can be obtained at:\r
19 * http://kstenerud.cjb.net\r
20 */\r
21\r
22/*\r
23 * Modified For OpenVMS By: Robert Alan Byer\r
24 * byer@mail.ourservers.net\r
25 */\r
26\r
27\r
28/* ======================================================================== */\r
29/* ============================ CODE GENERATOR ============================ */\r
30/* ======================================================================== */\r
31/*\r
32 * This is the code generator program which will generate the opcode table\r
33 * and the final opcode handlers.\r
34 *\r
35 * It requires an input file to function (default m68k_in.c), but you can\r
36 * specify your own like so:\r
37 *\r
38 * m68kmake <output path> <input file>\r
39 *\r
40 * where output path is the path where the output files should be placed, and\r
41 * input file is the file to use for input.\r
42 *\r
43 * If you modify the input file greatly from its released form, you may have\r
44 * to tweak the configuration section a bit since I'm using static allocation\r
45 * to keep things simple.\r
46 *\r
47 *\r
48 * TODO: - build a better code generator for the move instruction.\r
49 * - Add callm and rtm instructions\r
50 * - Fix RTE to handle other format words\r
51 * - Add address error (and bus error?) handling\r
52 */\r
53\r
54\r
55static const char* g_version = "3.31";\r
56\r
57/* ======================================================================== */\r
58/* =============================== INCLUDES =============================== */\r
59/* ======================================================================== */\r
60\r
61#include <stdio.h>\r
62#include <stdlib.h>\r
63#include <string.h>\r
64#include <ctype.h>\r
65#include <stdarg.h>\r
66\r
67\r
68\r
69/* ======================================================================== */\r
70/* ============================= CONFIGURATION ============================ */\r
71/* ======================================================================== */\r
72\r
73#define M68K_MAX_PATH 1024\r
74#define M68K_MAX_DIR 1024\r
75\r
76#define MAX_LINE_LENGTH 200 /* length of 1 line */\r
77#define MAX_BODY_LENGTH 300 /* Number of lines in 1 function */\r
78#define MAX_REPLACE_LENGTH 30 /* Max number of replace strings */\r
79#define MAX_INSERT_LENGTH 5000 /* Max size of insert piece */\r
80#define MAX_NAME_LENGTH 30 /* Max length of ophandler name */\r
81#define MAX_SPEC_PROC_LENGTH 4 /* Max length of special processing str */\r
82#define MAX_SPEC_EA_LENGTH 5 /* Max length of specified EA str */\r
83#define EA_ALLOWED_LENGTH 11 /* Max length of ea allowed str */\r
84#define MAX_OPCODE_INPUT_TABLE_LENGTH 1000 /* Max length of opcode handler tbl */\r
85#define MAX_OPCODE_OUTPUT_TABLE_LENGTH 3000 /* Max length of opcode handler tbl */\r
86\r
87/* Default filenames */\r
88#define FILENAME_INPUT "m68k_in.c"\r
89#define FILENAME_PROTOTYPE "m68kops.h"\r
90#define FILENAME_TABLE "m68kops.c"\r
91\r
92\r
93/* Identifier sequences recognized by this program */\r
94\r
95#define ID_INPUT_SEPARATOR "XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"\r
96\r
97#define ID_BASE "M68KMAKE"\r
98#define ID_PROTOTYPE_HEADER ID_BASE "_PROTOTYPE_HEADER"\r
99#define ID_PROTOTYPE_FOOTER ID_BASE "_PROTOTYPE_FOOTER"\r
100#define ID_TABLE_HEADER ID_BASE "_TABLE_HEADER"\r
101#define ID_TABLE_FOOTER ID_BASE "_TABLE_FOOTER"\r
102#define ID_TABLE_BODY ID_BASE "_TABLE_BODY"\r
103#define ID_TABLE_START ID_BASE "_TABLE_START"\r
104#define ID_OPHANDLER_HEADER ID_BASE "_OPCODE_HANDLER_HEADER"\r
105#define ID_OPHANDLER_FOOTER ID_BASE "_OPCODE_HANDLER_FOOTER"\r
106#define ID_OPHANDLER_BODY ID_BASE "_OPCODE_HANDLER_BODY"\r
107#define ID_END ID_BASE "_END"\r
108\r
109#define ID_OPHANDLER_NAME ID_BASE "_OP"\r
110#define ID_OPHANDLER_EA_AY_8 ID_BASE "_GET_EA_AY_8"\r
111#define ID_OPHANDLER_EA_AY_16 ID_BASE "_GET_EA_AY_16"\r
112#define ID_OPHANDLER_EA_AY_32 ID_BASE "_GET_EA_AY_32"\r
113#define ID_OPHANDLER_OPER_AY_8 ID_BASE "_GET_OPER_AY_8"\r
114#define ID_OPHANDLER_OPER_AY_16 ID_BASE "_GET_OPER_AY_16"\r
115#define ID_OPHANDLER_OPER_AY_32 ID_BASE "_GET_OPER_AY_32"\r
116#define ID_OPHANDLER_CC ID_BASE "_CC"\r
117#define ID_OPHANDLER_NOT_CC ID_BASE "_NOT_CC"\r
118\r
119\r
120#ifndef DECL_SPEC\r
121#define DECL_SPEC\r
122#endif /* DECL_SPEC */\r
123\r
124\r
125#ifdef USE_LIBRETRO_VFS\r
126#include "file_stream_transforms.h"\r
127#endif\r
128\r
129/* ======================================================================== */\r
130/* ============================== PROTOTYPES ============================== */\r
131/* ======================================================================== */\r
132\r
133enum {\r
134 CPU_TYPE_000 = 0,\r
135 CPU_TYPE_010,\r
136 CPU_TYPE_020,\r
137 CPU_TYPE_040,\r
138 NUM_CPUS\r
139};\r
140\r
141#define UNSPECIFIED "."\r
142#define UNSPECIFIED_CH '.'\r
143\r
144#define HAS_NO_EA_MODE(A) (strcmp(A, "..........") == 0)\r
145#define HAS_EA_AI(A) ((A)[0] == 'A')\r
146#define HAS_EA_PI(A) ((A)[1] == '+')\r
147#define HAS_EA_PD(A) ((A)[2] == '-')\r
148#define HAS_EA_DI(A) ((A)[3] == 'D')\r
149#define HAS_EA_IX(A) ((A)[4] == 'X')\r
150#define HAS_EA_AW(A) ((A)[5] == 'W')\r
151#define HAS_EA_AL(A) ((A)[6] == 'L')\r
152#define HAS_EA_PCDI(A) ((A)[7] == 'd')\r
153#define HAS_EA_PCIX(A) ((A)[8] == 'x')\r
154#define HAS_EA_I(A) ((A)[9] == 'I')\r
155\r
156enum\r
157{\r
158 EA_MODE_NONE, /* No special addressing mode */\r
159 EA_MODE_AI, /* Address register indirect */\r
160 EA_MODE_PI, /* Address register indirect with postincrement */\r
161 EA_MODE_PI7, /* Address register 7 indirect with postincrement */\r
162 EA_MODE_PD, /* Address register indirect with predecrement */\r
163 EA_MODE_PD7, /* Address register 7 indirect with predecrement */\r
164 EA_MODE_DI, /* Address register indirect with displacement */\r
165 EA_MODE_IX, /* Address register indirect with index */\r
166 EA_MODE_AW, /* Absolute word */\r
167 EA_MODE_AL, /* Absolute long */\r
168 EA_MODE_PCDI, /* Program counter indirect with displacement */\r
169 EA_MODE_PCIX, /* Program counter indirect with index */\r
170 EA_MODE_I /* Immediate */\r
171};\r
172\r
173\r
174/* Everything we need to know about an opcode */\r
175typedef struct\r
176{\r
177 char name[MAX_NAME_LENGTH]; /* opcode handler name */\r
178 unsigned char size; /* Size of operation */\r
179 char spec_proc[MAX_SPEC_PROC_LENGTH]; /* Special processing mode */\r
180 char spec_ea[MAX_SPEC_EA_LENGTH]; /* Specified effective addressing mode */\r
181 unsigned char bits; /* Number of significant bits (used for sorting the table) */\r
182 unsigned short op_mask; /* Mask to apply for matching an opcode to a handler */\r
183 unsigned short op_match; /* Value to match after masking */\r
184 char ea_allowed[EA_ALLOWED_LENGTH]; /* Effective addressing modes allowed */\r
185 char cpu_mode[NUM_CPUS]; /* User or supervisor mode */\r
186 char cpus[NUM_CPUS+1]; /* Allowed CPUs */\r
187 unsigned char cycles[NUM_CPUS]; /* cycles for 000, 010, 020 */\r
188} opcode_struct;\r
189\r
190\r
191/* All modifications necessary for a specific EA mode of an instruction */\r
192typedef struct\r
193{\r
194 const char* fname_add;\r
195 const char* ea_add;\r
196 unsigned int mask_add;\r
197 unsigned int match_add;\r
198} ea_info_struct;\r
199\r
200\r
201/* Holds the body of a function */\r
202typedef struct\r
203{\r
204 char body[MAX_BODY_LENGTH][MAX_LINE_LENGTH+1];\r
205 int length;\r
206} body_struct;\r
207\r
208\r
209/* Holds a sequence of search / replace strings */\r
210typedef struct\r
211{\r
212 char replace[MAX_REPLACE_LENGTH][2][MAX_LINE_LENGTH+1];\r
213 int length;\r
214} replace_struct;\r
215\r
216\r
217/* Function Prototypes */\r
218void error_exit(const char* fmt, ...);\r
219void perror_exit(const char* fmt, ...);\r
220int check_strsncpy(char* dst, char* src, int maxlength);\r
221int check_atoi(char* str, int *result);\r
222int skip_spaces(char* str);\r
223int num_bits(int value);\r
224int atoh(char* buff);\r
225int fgetline(char* buff, int nchars, FILE* file);\r
226int get_oper_cycles(opcode_struct* op, int ea_mode, int cpu_type);\r
227opcode_struct* find_opcode(char* name, int size, char* spec_proc, char* spec_ea);\r
228opcode_struct* find_illegal_opcode(void);\r
229int extract_opcode_info(char* src, char* name, int* size, char* spec_proc, char* spec_ea);\r
230void add_replace_string(replace_struct* replace, const char* search_str, const char* replace_str);\r
231void write_body(FILE* filep, body_struct* body, replace_struct* replace);\r
232void get_base_name(char* base_name, opcode_struct* op);\r
233void write_prototype(FILE* filep, char* base_name);\r
234void write_function_name(FILE* filep, char* base_name);\r
235void add_opcode_output_table_entry(opcode_struct* op, char* name);\r
236static int DECL_SPEC compare_nof_true_bits(const void* aptr, const void* bptr);\r
237void print_opcode_output_table(FILE* filep);\r
238void write_table_entry(FILE* filep, opcode_struct* op);\r
239void set_opcode_struct(opcode_struct* src, opcode_struct* dst, int ea_mode);\r
240void generate_opcode_handler(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* opinfo, int ea_mode);\r
241void generate_opcode_ea_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op);\r
242void generate_opcode_cc_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op_in, int offset);\r
243void process_opcode_handlers(FILE* filep);\r
244void populate_table(void);\r
245void read_insert(char* insert);\r
246\r
247\r
248\r
249/* ======================================================================== */\r
250/* ================================= DATA ================================= */\r
251/* ======================================================================== */\r
252\r
253/* Name of the input file */\r
254char g_input_filename[M68K_MAX_PATH] = FILENAME_INPUT;\r
255\r
256/* File handles */\r
257FILE* g_input_file = NULL;\r
258FILE* g_prototype_file = NULL;\r
259FILE* g_table_file = NULL;\r
260\r
261int g_num_functions = 0; /* Number of functions processed */\r
262int g_num_primitives = 0; /* Number of function primitives read */\r
263int g_line_number = 1; /* Current line number */\r
264\r
265/* Opcode handler table */\r
266opcode_struct g_opcode_input_table[MAX_OPCODE_INPUT_TABLE_LENGTH];\r
267\r
268opcode_struct g_opcode_output_table[MAX_OPCODE_OUTPUT_TABLE_LENGTH];\r
269int g_opcode_output_table_length = 0;\r
270\r
271ea_info_struct g_ea_info_table[13] =\r
272{/* fname ea mask match */\r
273 {"", "", 0x00, 0x00}, /* EA_MODE_NONE */\r
274 {"ai", "AY_AI", 0x38, 0x10}, /* EA_MODE_AI */\r
275 {"pi", "AY_PI", 0x38, 0x18}, /* EA_MODE_PI */\r
276 {"pi7", "A7_PI", 0x3f, 0x1f}, /* EA_MODE_PI7 */\r
277 {"pd", "AY_PD", 0x38, 0x20}, /* EA_MODE_PD */\r
278 {"pd7", "A7_PD", 0x3f, 0x27}, /* EA_MODE_PD7 */\r
279 {"di", "AY_DI", 0x38, 0x28}, /* EA_MODE_DI */\r
280 {"ix", "AY_IX", 0x38, 0x30}, /* EA_MODE_IX */\r
281 {"aw", "AW", 0x3f, 0x38}, /* EA_MODE_AW */\r
282 {"al", "AL", 0x3f, 0x39}, /* EA_MODE_AL */\r
283 {"pcdi", "PCDI", 0x3f, 0x3a}, /* EA_MODE_PCDI */\r
284 {"pcix", "PCIX", 0x3f, 0x3b}, /* EA_MODE_PCIX */\r
285 {"i", "I", 0x3f, 0x3c}, /* EA_MODE_I */\r
286};\r
287\r
288\r
289const char* g_cc_table[16][2] =\r
290{\r
291 { "t", "T"}, /* 0000 */\r
292 { "f", "F"}, /* 0001 */\r
293 {"hi", "HI"}, /* 0010 */\r
294 {"ls", "LS"}, /* 0011 */\r
295 {"cc", "CC"}, /* 0100 */\r
296 {"cs", "CS"}, /* 0101 */\r
297 {"ne", "NE"}, /* 0110 */\r
298 {"eq", "EQ"}, /* 0111 */\r
299 {"vc", "VC"}, /* 1000 */\r
300 {"vs", "VS"}, /* 1001 */\r
301 {"pl", "PL"}, /* 1010 */\r
302 {"mi", "MI"}, /* 1011 */\r
303 {"ge", "GE"}, /* 1100 */\r
304 {"lt", "LT"}, /* 1101 */\r
305 {"gt", "GT"}, /* 1110 */\r
306 {"le", "LE"}, /* 1111 */\r
307};\r
308\r
309/* size to index translator (0 -> 0, 8 and 16 -> 1, 32 -> 2) */\r
310int g_size_select_table[33] =\r
311{\r
312 0, /* unsized */\r
313 0, 0, 0, 0, 0, 0, 0, 1, /* 8 */\r
314 0, 0, 0, 0, 0, 0, 0, 1, /* 16 */\r
315 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2 /* 32 */\r
316};\r
317\r
318/* Extra cycles required for certain EA modes */\r
319/* TODO: correct timings for 040 */\r
320int g_ea_cycle_table[13][NUM_CPUS][3] =\r
321{/* 000 010 020 040 */\r
322 {{ 0, 0, 0}, { 0, 0, 0}, { 0, 0, 0}, { 0, 0, 0}}, /* EA_MODE_NONE */\r
323 {{ 0, 4, 8}, { 0, 4, 8}, { 0, 4, 4}, { 0, 4, 4}}, /* EA_MODE_AI */\r
324 {{ 0, 4, 8}, { 0, 4, 8}, { 0, 4, 4}, { 0, 4, 4}}, /* EA_MODE_PI */\r
325 {{ 0, 4, 8}, { 0, 4, 8}, { 0, 4, 4}, { 0, 4, 4}}, /* EA_MODE_PI7 */\r
326 {{ 0, 6, 10}, { 0, 6, 10}, { 0, 5, 5}, { 0, 5, 5}}, /* EA_MODE_PD */\r
327 {{ 0, 6, 10}, { 0, 6, 10}, { 0, 5, 5}, { 0, 5, 5}}, /* EA_MODE_PD7 */\r
328 {{ 0, 8, 12}, { 0, 8, 12}, { 0, 5, 5}, { 0, 5, 5}}, /* EA_MODE_DI */\r
329 {{ 0, 10, 14}, { 0, 10, 14}, { 0, 7, 7}, { 0, 7, 7}}, /* EA_MODE_IX */\r
330 {{ 0, 8, 12}, { 0, 8, 12}, { 0, 4, 4}, { 0, 4, 4}}, /* EA_MODE_AW */\r
331 {{ 0, 12, 16}, { 0, 12, 16}, { 0, 4, 4}, { 0, 4, 4}}, /* EA_MODE_AL */\r
332 {{ 0, 8, 12}, { 0, 8, 12}, { 0, 5, 5}, { 0, 5, 5}}, /* EA_MODE_PCDI */\r
333 {{ 0, 10, 14}, { 0, 10, 14}, { 0, 7, 7}, { 0, 7, 7}}, /* EA_MODE_PCIX */\r
334 {{ 0, 4, 8}, { 0, 4, 8}, { 0, 2, 4}, { 0, 2, 4}}, /* EA_MODE_I */\r
335};\r
336\r
337/* Extra cycles for JMP instruction (000, 010) */\r
338int g_jmp_cycle_table[13] =\r
339{\r
340 0, /* EA_MODE_NONE */\r
341 4, /* EA_MODE_AI */\r
342 0, /* EA_MODE_PI */\r
343 0, /* EA_MODE_PI7 */\r
344 0, /* EA_MODE_PD */\r
345 0, /* EA_MODE_PD7 */\r
346 6, /* EA_MODE_DI */\r
347 10, /* EA_MODE_IX */\r
348 6, /* EA_MODE_AW */\r
349 8, /* EA_MODE_AL */\r
350 6, /* EA_MODE_PCDI */\r
351 10, /* EA_MODE_PCIX */\r
352 0, /* EA_MODE_I */\r
353};\r
354\r
355/* Extra cycles for JSR instruction (000, 010) */\r
356int g_jsr_cycle_table[13] =\r
357{\r
358 0, /* EA_MODE_NONE */\r
359 4, /* EA_MODE_AI */\r
360 0, /* EA_MODE_PI */\r
361 0, /* EA_MODE_PI7 */\r
362 0, /* EA_MODE_PD */\r
363 0, /* EA_MODE_PD7 */\r
364 6, /* EA_MODE_DI */\r
365 10, /* EA_MODE_IX */\r
366 6, /* EA_MODE_AW */\r
367 8, /* EA_MODE_AL */\r
368 6, /* EA_MODE_PCDI */\r
369 10, /* EA_MODE_PCIX */\r
370 0, /* EA_MODE_I */\r
371};\r
372\r
373/* Extra cycles for LEA instruction (000, 010) */\r
374int g_lea_cycle_table[13] =\r
375{\r
376 0, /* EA_MODE_NONE */\r
377 4, /* EA_MODE_AI */\r
378 0, /* EA_MODE_PI */\r
379 0, /* EA_MODE_PI7 */\r
380 0, /* EA_MODE_PD */\r
381 0, /* EA_MODE_PD7 */\r
382 8, /* EA_MODE_DI */\r
383 12, /* EA_MODE_IX */\r
384 8, /* EA_MODE_AW */\r
385 12, /* EA_MODE_AL */\r
386 8, /* EA_MODE_PCDI */\r
387 12, /* EA_MODE_PCIX */\r
388 0, /* EA_MODE_I */\r
389};\r
390\r
391/* Extra cycles for PEA instruction (000, 010) */\r
392int g_pea_cycle_table[13] =\r
393{\r
394 0, /* EA_MODE_NONE */\r
395 6, /* EA_MODE_AI */\r
396 0, /* EA_MODE_PI */\r
397 0, /* EA_MODE_PI7 */\r
398 0, /* EA_MODE_PD */\r
399 0, /* EA_MODE_PD7 */\r
400 10, /* EA_MODE_DI */\r
401 14, /* EA_MODE_IX */\r
402 10, /* EA_MODE_AW */\r
403 14, /* EA_MODE_AL */\r
404 10, /* EA_MODE_PCDI */\r
405 14, /* EA_MODE_PCIX */\r
406 0, /* EA_MODE_I */\r
407};\r
408\r
409/* Extra cycles for MOVEM instruction (000, 010) */\r
410int g_movem_cycle_table[13] =\r
411{\r
412 0, /* EA_MODE_NONE */\r
413 0, /* EA_MODE_AI */\r
414 0, /* EA_MODE_PI */\r
415 0, /* EA_MODE_PI7 */\r
416 0, /* EA_MODE_PD */\r
417 0, /* EA_MODE_PD7 */\r
418 4, /* EA_MODE_DI */\r
419 6, /* EA_MODE_IX */\r
420 4, /* EA_MODE_AW */\r
421 8, /* EA_MODE_AL */\r
422 0, /* EA_MODE_PCDI */\r
423 0, /* EA_MODE_PCIX */\r
424 0, /* EA_MODE_I */\r
425};\r
426\r
427/* Extra cycles for MOVES instruction (010) */\r
428int g_moves_cycle_table[13][3] =\r
429{\r
430 { 0, 0, 0}, /* EA_MODE_NONE */\r
431 { 0, 4, 6}, /* EA_MODE_AI */\r
432 { 0, 4, 6}, /* EA_MODE_PI */\r
433 { 0, 4, 6}, /* EA_MODE_PI7 */\r
434 { 0, 6, 12}, /* EA_MODE_PD */\r
435 { 0, 6, 12}, /* EA_MODE_PD7 */\r
436 { 0, 12, 16}, /* EA_MODE_DI */\r
437 { 0, 16, 20}, /* EA_MODE_IX */\r
438 { 0, 12, 16}, /* EA_MODE_AW */\r
439 { 0, 16, 20}, /* EA_MODE_AL */\r
440 { 0, 0, 0}, /* EA_MODE_PCDI */\r
441 { 0, 0, 0}, /* EA_MODE_PCIX */\r
442 { 0, 0, 0}, /* EA_MODE_I */\r
443};\r
444\r
445/* Extra cycles for CLR instruction (010) */\r
446int g_clr_cycle_table[13][3] =\r
447{\r
448 { 0, 0, 0}, /* EA_MODE_NONE */\r
449 { 0, 4, 6}, /* EA_MODE_AI */\r
450 { 0, 4, 6}, /* EA_MODE_PI */\r
451 { 0, 4, 6}, /* EA_MODE_PI7 */\r
452 { 0, 6, 8}, /* EA_MODE_PD */\r
453 { 0, 6, 8}, /* EA_MODE_PD7 */\r
454 { 0, 8, 10}, /* EA_MODE_DI */\r
455 { 0, 10, 14}, /* EA_MODE_IX */\r
456 { 0, 8, 10}, /* EA_MODE_AW */\r
457 { 0, 10, 14}, /* EA_MODE_AL */\r
458 { 0, 0, 0}, /* EA_MODE_PCDI */\r
459 { 0, 0, 0}, /* EA_MODE_PCIX */\r
460 { 0, 0, 0}, /* EA_MODE_I */\r
461};\r
462\r
463\r
464\r
465/* ======================================================================== */\r
466/* =========================== UTILITY FUNCTIONS ========================== */\r
467/* ======================================================================== */\r
468\r
469/* Print an error message and exit with status error */\r
470void error_exit(const char* fmt, ...)\r
471{\r
472 va_list args;\r
473 fprintf(stderr, "In %s, near or on line %d:\n\t", g_input_filename, g_line_number);\r
474 va_start(args, fmt);\r
475 vfprintf(stderr, fmt, args);\r
476 va_end(args);\r
477 fprintf(stderr, "\n");\r
478\r
479 if(g_prototype_file) fclose(g_prototype_file);\r
480 if(g_table_file) fclose(g_table_file);\r
481 if(g_input_file) fclose(g_input_file);\r
482\r
483 exit(EXIT_FAILURE);\r
484}\r
485\r
486/* Print an error message, call perror(), and exit with status error */\r
487void perror_exit(const char* fmt, ...)\r
488{\r
489 va_list args;\r
490 va_start(args, fmt);\r
491 vfprintf(stderr, fmt, args);\r
492 va_end(args);\r
493 perror("");\r
494\r
495 if(g_prototype_file) fclose(g_prototype_file);\r
496 if(g_table_file) fclose(g_table_file);\r
497 if(g_input_file) fclose(g_input_file);\r
498\r
499 exit(EXIT_FAILURE);\r
500}\r
501\r
502\r
503/* copy until 0 or space and exit with error if we read too far */\r
504int check_strsncpy(char* dst, char* src, int maxlength)\r
505{\r
506 char* p = dst;\r
507 while(*src && *src != ' ')\r
508 {\r
509 *p++ = *src++;\r
510 if(p - dst > maxlength)\r
511 error_exit("Field too long");\r
512 }\r
513 *p = 0;\r
514 return p - dst;\r
515}\r
516\r
517/* copy until 0 or specified character and exit with error if we read too far */\r
518int check_strcncpy(char* dst, char* src, char delim, int maxlength)\r
519{\r
520 char* p = dst;\r
521 while(*src && *src != delim)\r
522 {\r
523 *p++ = *src++;\r
524 if(p - dst > maxlength)\r
525 error_exit("Field too long");\r
526 }\r
527 *p = 0;\r
528 return p - dst;\r
529}\r
530\r
531/* convert ascii to integer and exit with error if we find invalid data */\r
532int check_atoi(char* str, int *result)\r
533{\r
534 int accum = 0;\r
535 char* p = str;\r
536 while(*p >= '0' && *p <= '9')\r
537 {\r
538 accum *= 10;\r
539 accum += *p++ - '0';\r
540 }\r
541 if(*p != ' ' && *p != 0)\r
542 error_exit("Malformed integer value (%c)", *p);\r
543 *result = accum;\r
544 return p - str;\r
545}\r
546\r
547/* Skip past spaces in a string */\r
548int skip_spaces(char* str)\r
549{\r
550 char* p = str;\r
551\r
552 while(*p == ' ')\r
553 p++;\r
554\r
555 return p - str;\r
556}\r
557\r
558/* Count the number of set bits in a value */\r
559int num_bits(int value)\r
560{\r
561 value = ((value & 0xaaaa) >> 1) + (value & 0x5555);\r
562 value = ((value & 0xcccc) >> 2) + (value & 0x3333);\r
563 value = ((value & 0xf0f0) >> 4) + (value & 0x0f0f);\r
564 value = ((value & 0xff00) >> 8) + (value & 0x00ff);\r
565 return value;\r
566}\r
567\r
568/* Convert a hex value written in ASCII */\r
569int atoh(char* buff)\r
570{\r
571 int accum = 0;\r
572\r
573 for(;;buff++)\r
574 {\r
575 if(*buff >= '0' && *buff <= '9')\r
576 {\r
577 accum <<= 4;\r
578 accum += *buff - '0';\r
579 }\r
580 else if(*buff >= 'a' && *buff <= 'f')\r
581 {\r
582 accum <<= 4;\r
583 accum += *buff - 'a' + 10;\r
584 }\r
585 else break;\r
586 }\r
587 return accum;\r
588}\r
589\r
590/* Get a line of text from a file, discarding any end-of-line characters */\r
591int fgetline(char* buff, int nchars, FILE* file)\r
592{\r
593 int length;\r
594\r
595 if(fgets(buff, nchars, file) == NULL)\r
596 return -1;\r
597 if(buff[0] == '\r')\r
598 memcpy(buff, buff + 1, nchars - 1);\r
599\r
600 length = strlen(buff);\r
601 while(length && (buff[length-1] == '\r' || buff[length-1] == '\n'))\r
602 length--;\r
603 buff[length] = 0;\r
604 g_line_number++;\r
605\r
606 return length;\r
607}\r
608\r
609\r
610\r
611/* ======================================================================== */\r
612/* =========================== HELPER FUNCTIONS =========================== */\r
613/* ======================================================================== */\r
614\r
615/* Calculate the number of cycles an opcode requires */\r
616int get_oper_cycles(opcode_struct* op, int ea_mode, int cpu_type)\r
617{\r
618 int size = g_size_select_table[op->size];\r
619\r
620 if(op->cpus[cpu_type] == '.')\r
621 return 0;\r
622\r
623 if(cpu_type < CPU_TYPE_020)\r
624 {\r
625 if(cpu_type == CPU_TYPE_010)\r
626 {\r
627 if(strcmp(op->name, "moves") == 0)\r
628 return op->cycles[cpu_type] + g_moves_cycle_table[ea_mode][size];\r
629 if(strcmp(op->name, "clr") == 0)\r
630 return op->cycles[cpu_type] + g_clr_cycle_table[ea_mode][size];\r
631 }\r
632\r
633 /* ASG: added these cases -- immediate modes take 2 extra cycles here */\r
634 /* SV: but only when operating on long, and also on register direct mode */\r
635 if(cpu_type == CPU_TYPE_000 && (ea_mode == EA_MODE_I || ea_mode == EA_MODE_NONE) && op->size == 32 &&\r
636 ((strcmp(op->name, "add") == 0 && strcmp(op->spec_proc, "er") == 0) ||\r
637 strcmp(op->name, "adda") == 0 ||\r
638 (strcmp(op->name, "and") == 0 && strcmp(op->spec_proc, "er") == 0) ||\r
639 (strcmp(op->name, "or") == 0 && strcmp(op->spec_proc, "er") == 0) ||\r
640 (strcmp(op->name, "sub") == 0 && strcmp(op->spec_proc, "er") == 0) ||\r
641 strcmp(op->name, "suba") == 0))\r
642 return op->cycles[cpu_type] + g_ea_cycle_table[ea_mode][cpu_type][size] + 2;\r
643\r
644 if(cpu_type == CPU_TYPE_000 && ea_mode == EA_MODE_I && op->size == 8 && strcmp(op->name, "btst") == 0)\r
645 return op->cycles[cpu_type] + g_ea_cycle_table[ea_mode][cpu_type][size] + 2;\r
646\r
647 if(strcmp(op->name, "jmp") == 0)\r
648 return op->cycles[cpu_type] + g_jmp_cycle_table[ea_mode];\r
649 if(strcmp(op->name, "jsr") == 0)\r
650 return op->cycles[cpu_type] + g_jsr_cycle_table[ea_mode];\r
651 if(strcmp(op->name, "lea") == 0)\r
652 return op->cycles[cpu_type] + g_lea_cycle_table[ea_mode];\r
653 if(strcmp(op->name, "pea") == 0)\r
654 return op->cycles[cpu_type] + g_pea_cycle_table[ea_mode];\r
655 if(strcmp(op->name, "movem") == 0)\r
656 return op->cycles[cpu_type] + g_movem_cycle_table[ea_mode];\r
657 }\r
658 return op->cycles[cpu_type] + g_ea_cycle_table[ea_mode][cpu_type][size];\r
659}\r
660\r
661/* Find an opcode in the opcode handler list */\r
662opcode_struct* find_opcode(char* name, int size, char* spec_proc, char* spec_ea)\r
663{\r
664 opcode_struct* op;\r
665\r
666\r
667 for(op = g_opcode_input_table;op->name != NULL;op++)\r
668 {\r
669 if( strcmp(name, op->name) == 0 &&\r
670 (size == op->size) &&\r
671 strcmp(spec_proc, op->spec_proc) == 0 &&\r
672 strcmp(spec_ea, op->spec_ea) == 0)\r
673 return op;\r
674 }\r
675 return NULL;\r
676}\r
677\r
678/* Specifically find the illegal opcode in the list */\r
679opcode_struct* find_illegal_opcode(void)\r
680{\r
681 opcode_struct* op;\r
682\r
683 for(op = g_opcode_input_table;op->name != NULL;op++)\r
684 {\r
685 if(strcmp(op->name, "illegal") == 0)\r
686 return op;\r
687 }\r
688 return NULL;\r
689}\r
690\r
691/* Parse an opcode handler name */\r
692int extract_opcode_info(char* src, char* name, int* size, char* spec_proc, char* spec_ea)\r
693{\r
694 char* ptr = strstr(src, ID_OPHANDLER_NAME);\r
695\r
696 if(ptr == NULL)\r
697 return 0;\r
698\r
699 ptr += strlen(ID_OPHANDLER_NAME) + 1;\r
700\r
701 ptr += check_strcncpy(name, ptr, ',', MAX_NAME_LENGTH);\r
702 if(*ptr != ',') return 0;\r
703 ptr++;\r
704 ptr += skip_spaces(ptr);\r
705\r
706 *size = atoi(ptr);\r
707 ptr = strstr(ptr, ",");\r
708 if(ptr == NULL) return 0;\r
709 ptr++;\r
710 ptr += skip_spaces(ptr);\r
711\r
712 ptr += check_strcncpy(spec_proc, ptr, ',', MAX_SPEC_PROC_LENGTH);\r
713 if(*ptr != ',') return 0;\r
714 ptr++;\r
715 ptr += skip_spaces(ptr);\r
716\r
717 ptr += check_strcncpy(spec_ea, ptr, ')', MAX_SPEC_EA_LENGTH);\r
718 if(*ptr != ')') return 0;\r
719 ptr++;\r
720 ptr += skip_spaces(ptr);\r
721\r
722 return 1;\r
723}\r
724\r
725\r
726/* Add a search/replace pair to a replace structure */\r
727void add_replace_string(replace_struct* replace, const char* search_str, const char* replace_str)\r
728{\r
729 if(replace->length >= MAX_REPLACE_LENGTH)\r
730 error_exit("overflow in replace structure");\r
731\r
732 strcpy(replace->replace[replace->length][0], search_str);\r
733 strcpy(replace->replace[replace->length++][1], replace_str);\r
734}\r
735\r
736/* Write a function body while replacing any selected strings */\r
737void write_body(FILE* filep, body_struct* body, replace_struct* replace)\r
738{\r
739 int i;\r
740 int j;\r
741 char* ptr;\r
742 char output[MAX_LINE_LENGTH+1];\r
743 char temp_buff[MAX_LINE_LENGTH+1];\r
744 int found;\r
745\r
746 for(i=0;i<body->length;i++)\r
747 {\r
748 strcpy(output, body->body[i]);\r
749 /* Check for the base directive header */\r
750 if(strstr(output, ID_BASE) != NULL)\r
751 {\r
752 /* Search for any text we need to replace */\r
753 found = 0;\r
754 for(j=0;j<replace->length;j++)\r
755 {\r
756 ptr = strstr(output, replace->replace[j][0]);\r
757 if(ptr)\r
758 {\r
759 /* We found something to replace */\r
760 found = 1;\r
761 strcpy(temp_buff, ptr+strlen(replace->replace[j][0]));\r
762 strcpy(ptr, replace->replace[j][1]);\r
763 strcat(ptr, temp_buff);\r
764 }\r
765 }\r
766 /* Found a directive with no matching replace string */\r
767 if(!found)\r
768 error_exit("Unknown " ID_BASE " directive");\r
769 }\r
770 fprintf(filep, "%s\n", output);\r
771 }\r
772 fprintf(filep, "\n\n");\r
773}\r
774\r
775/* Generate a base function name from an opcode struct */\r
776void get_base_name(char* base_name, opcode_struct* op)\r
777{\r
778 sprintf(base_name, "m68k_op_%s", op->name);\r
779 if(op->size > 0)\r
780 sprintf(base_name+strlen(base_name), "_%d", op->size);\r
781 if(strcmp(op->spec_proc, UNSPECIFIED) != 0)\r
782 sprintf(base_name+strlen(base_name), "_%s", op->spec_proc);\r
783 if(strcmp(op->spec_ea, UNSPECIFIED) != 0)\r
784 sprintf(base_name+strlen(base_name), "_%s", op->spec_ea);\r
785}\r
786\r
787/* Write the prototype of an opcode handler function */\r
788void write_prototype(FILE* filep, char* base_name)\r
789{\r
790 fprintf(filep, "void %s(void);\n", base_name);\r
791}\r
792\r
793/* Write the name of an opcode handler function */\r
794void write_function_name(FILE* filep, char* base_name)\r
795{\r
796 fprintf(filep, "void %s(void)\n", base_name);\r
797}\r
798\r
799void add_opcode_output_table_entry(opcode_struct* op, char* name)\r
800{\r
801 opcode_struct* ptr;\r
802 if(g_opcode_output_table_length > MAX_OPCODE_OUTPUT_TABLE_LENGTH)\r
803 error_exit("Opcode output table overflow");\r
804\r
805 ptr = g_opcode_output_table + g_opcode_output_table_length++;\r
806\r
807 *ptr = *op;\r
808 strcpy(ptr->name, name);\r
809 ptr->bits = num_bits(ptr->op_mask);\r
810}\r
811\r
812/*\r
813 * Comparison function for qsort()\r
814 * For entries with an equal number of set bits in\r
815 * the mask compare the match values\r
816 */\r
817static int DECL_SPEC compare_nof_true_bits(const void* aptr, const void* bptr)\r
818{\r
819 const opcode_struct *a = aptr, *b = bptr;\r
820 if(a->bits != b->bits)\r
821 return a->bits - b->bits;\r
822 if(a->op_mask != b->op_mask)\r
823 return a->op_mask - b->op_mask;\r
824 return a->op_match - b->op_match;\r
825}\r
826\r
827void print_opcode_output_table(FILE* filep)\r
828{\r
829 int i;\r
830 qsort((void *)g_opcode_output_table, g_opcode_output_table_length, sizeof(g_opcode_output_table[0]), compare_nof_true_bits);\r
831\r
832 for(i=0;i<g_opcode_output_table_length;i++)\r
833 write_table_entry(filep, g_opcode_output_table+i);\r
834}\r
835\r
836/* Write an entry in the opcode handler table */\r
837void write_table_entry(FILE* filep, opcode_struct* op)\r
838{\r
839 int i;\r
840\r
841 fprintf(filep, "\t{%-28s, 0x%04x, 0x%04x, {",\r
842 op->name, op->op_mask, op->op_match);\r
843\r
844 for(i=0;i<NUM_CPUS;i++)\r
845 {\r
846 fprintf(filep, "%3d", op->cycles[i]);\r
847 if(i < NUM_CPUS-1)\r
848 fprintf(filep, ", ");\r
849 }\r
850\r
851 fprintf(filep, "}},\n");\r
852}\r
853\r
854/* Fill out an opcode struct with a specific addressing mode of the source opcode struct */\r
855void set_opcode_struct(opcode_struct* src, opcode_struct* dst, int ea_mode)\r
856{\r
857 int i;\r
858\r
859 *dst = *src;\r
860\r
861 for(i=0;i<NUM_CPUS;i++)\r
862 dst->cycles[i] = get_oper_cycles(dst, ea_mode, i);\r
863 if(strcmp(dst->spec_ea, UNSPECIFIED) == 0 && ea_mode != EA_MODE_NONE)\r
864 sprintf(dst->spec_ea, "%s", g_ea_info_table[ea_mode].fname_add);\r
865 dst->op_mask |= g_ea_info_table[ea_mode].mask_add;\r
866 dst->op_match |= g_ea_info_table[ea_mode].match_add;\r
867}\r
868\r
869\r
870/* Generate a final opcode handler from the provided data */\r
871void generate_opcode_handler(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* opinfo, int ea_mode)\r
872{\r
873 char str[MAX_LINE_LENGTH+1];\r
874 opcode_struct* op = malloc(sizeof(opcode_struct));\r
875\r
876 /* Set the opcode structure and write the tables, prototypes, etc */\r
877 set_opcode_struct(opinfo, op, ea_mode);\r
878 get_base_name(str, op);\r
879 write_prototype(g_prototype_file, str);\r
880 add_opcode_output_table_entry(op, str);\r
881 write_function_name(filep, str);\r
882\r
883 /* Add any replace strings needed */\r
884 if(ea_mode != EA_MODE_NONE)\r
885 {\r
886 sprintf(str, "EA_%s_8()", g_ea_info_table[ea_mode].ea_add);\r
887 add_replace_string(replace, ID_OPHANDLER_EA_AY_8, str);\r
888 sprintf(str, "EA_%s_16()", g_ea_info_table[ea_mode].ea_add);\r
889 add_replace_string(replace, ID_OPHANDLER_EA_AY_16, str);\r
890 sprintf(str, "EA_%s_32()", g_ea_info_table[ea_mode].ea_add);\r
891 add_replace_string(replace, ID_OPHANDLER_EA_AY_32, str);\r
892 sprintf(str, "OPER_%s_8()", g_ea_info_table[ea_mode].ea_add);\r
893 add_replace_string(replace, ID_OPHANDLER_OPER_AY_8, str);\r
894 sprintf(str, "OPER_%s_16()", g_ea_info_table[ea_mode].ea_add);\r
895 add_replace_string(replace, ID_OPHANDLER_OPER_AY_16, str);\r
896 sprintf(str, "OPER_%s_32()", g_ea_info_table[ea_mode].ea_add);\r
897 add_replace_string(replace, ID_OPHANDLER_OPER_AY_32, str);\r
898 }\r
899\r
900 /* Now write the function body with the selected replace strings */\r
901 write_body(filep, body, replace);\r
902 g_num_functions++;\r
903 free(op);\r
904}\r
905\r
906/* Generate opcode variants based on available addressing modes */\r
907void generate_opcode_ea_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op)\r
908{\r
909 int old_length = replace->length;\r
910\r
911 /* No ea modes available for this opcode */\r
912 if(HAS_NO_EA_MODE(op->ea_allowed))\r
913 {\r
914 generate_opcode_handler(filep, body, replace, op, EA_MODE_NONE);\r
915 return;\r
916 }\r
917\r
918 /* Check for and create specific opcodes for each available addressing mode */\r
919 if(HAS_EA_AI(op->ea_allowed))\r
920 generate_opcode_handler(filep, body, replace, op, EA_MODE_AI);\r
921 replace->length = old_length;\r
922 if(HAS_EA_PI(op->ea_allowed))\r
923 {\r
924 generate_opcode_handler(filep, body, replace, op, EA_MODE_PI);\r
925 replace->length = old_length;\r
926 if(op->size == 8)\r
927 generate_opcode_handler(filep, body, replace, op, EA_MODE_PI7);\r
928 }\r
929 replace->length = old_length;\r
930 if(HAS_EA_PD(op->ea_allowed))\r
931 {\r
932 generate_opcode_handler(filep, body, replace, op, EA_MODE_PD);\r
933 replace->length = old_length;\r
934 if(op->size == 8)\r
935 generate_opcode_handler(filep, body, replace, op, EA_MODE_PD7);\r
936 }\r
937 replace->length = old_length;\r
938 if(HAS_EA_DI(op->ea_allowed))\r
939 generate_opcode_handler(filep, body, replace, op, EA_MODE_DI);\r
940 replace->length = old_length;\r
941 if(HAS_EA_IX(op->ea_allowed))\r
942 generate_opcode_handler(filep, body, replace, op, EA_MODE_IX);\r
943 replace->length = old_length;\r
944 if(HAS_EA_AW(op->ea_allowed))\r
945 generate_opcode_handler(filep, body, replace, op, EA_MODE_AW);\r
946 replace->length = old_length;\r
947 if(HAS_EA_AL(op->ea_allowed))\r
948 generate_opcode_handler(filep, body, replace, op, EA_MODE_AL);\r
949 replace->length = old_length;\r
950 if(HAS_EA_PCDI(op->ea_allowed))\r
951 generate_opcode_handler(filep, body, replace, op, EA_MODE_PCDI);\r
952 replace->length = old_length;\r
953 if(HAS_EA_PCIX(op->ea_allowed))\r
954 generate_opcode_handler(filep, body, replace, op, EA_MODE_PCIX);\r
955 replace->length = old_length;\r
956 if(HAS_EA_I(op->ea_allowed))\r
957 generate_opcode_handler(filep, body, replace, op, EA_MODE_I);\r
958 replace->length = old_length;\r
959}\r
960\r
961/* Generate variants of condition code opcodes */\r
962void generate_opcode_cc_variants(FILE* filep, body_struct* body, replace_struct* replace, opcode_struct* op_in, int offset)\r
963{\r
964 char repl[20];\r
965 char replnot[20];\r
966 int i;\r
967 int old_length = replace->length;\r
968 opcode_struct* op = malloc(sizeof(opcode_struct));\r
969\r
970 *op = *op_in;\r
971\r
972 op->op_mask |= 0x0f00;\r
973\r
974 /* Do all condition codes except t and f */\r
975 for(i=2;i<16;i++)\r
976 {\r
977 /* Add replace strings for this condition code */\r
978 sprintf(repl, "COND_%s()", g_cc_table[i][1]);\r
979 sprintf(replnot, "COND_NOT_%s()", g_cc_table[i][1]);\r
980\r
981 add_replace_string(replace, ID_OPHANDLER_CC, repl);\r
982 add_replace_string(replace, ID_OPHANDLER_NOT_CC, replnot);\r
983\r
984 /* Set the new opcode info */\r
985 strcpy(op->name+offset, g_cc_table[i][0]);\r
986\r
987 op->op_match = (op->op_match & 0xf0ff) | (i<<8);\r
988\r
989 /* Generate all opcode variants for this modified opcode */\r
990 generate_opcode_ea_variants(filep, body, replace, op);\r
991 /* Remove the above replace strings */\r
992 replace->length = old_length;\r
993 }\r
994 free(op);\r
995}\r
996\r
997/* Process the opcode handlers section of the input file */\r
998void process_opcode_handlers(FILE* filep)\r
999{\r
1000 FILE* input_file = g_input_file;\r
1001 char func_name[MAX_LINE_LENGTH+1];\r
1002 char oper_name[MAX_LINE_LENGTH+1];\r
1003 int oper_size;\r
1004 char oper_spec_proc[MAX_LINE_LENGTH+1];\r
1005 char oper_spec_ea[MAX_LINE_LENGTH+1];\r
1006 opcode_struct* opinfo;\r
1007 replace_struct* replace = malloc(sizeof(replace_struct));\r
1008 body_struct* body = malloc(sizeof(body_struct));\r
1009\r
1010 for(;;)\r
1011 {\r
1012 /* Find the first line of the function */\r
1013 func_name[0] = 0;\r
1014 while(strstr(func_name, ID_OPHANDLER_NAME) == NULL)\r
1015 {\r
1016 if(strcmp(func_name, ID_INPUT_SEPARATOR) == 0)\r
1017 {\r
1018 free(replace);\r
1019 free(body);\r
1020 return; /* all done */\r
1021 }\r
1022 if(fgetline(func_name, MAX_LINE_LENGTH, input_file) < 0)\r
1023 error_exit("Premature end of file when getting function name");\r
1024 }\r
1025 /* Get the rest of the function */\r
1026 for(body->length=0;;body->length++)\r
1027 {\r
1028 if(body->length > MAX_BODY_LENGTH)\r
1029 error_exit("Function too long");\r
1030\r
1031 if(fgetline(body->body[body->length], MAX_LINE_LENGTH, input_file) < 0)\r
1032 error_exit("Premature end of file when getting function body");\r
1033\r
1034 if(body->body[body->length][0] == '}')\r
1035 {\r
1036 body->length++;\r
1037 break;\r
1038 }\r
1039 }\r
1040\r
1041 g_num_primitives++;\r
1042\r
1043 /* Extract the function name information */\r
1044 if(!extract_opcode_info(func_name, oper_name, &oper_size, oper_spec_proc, oper_spec_ea))\r
1045 error_exit("Invalid " ID_OPHANDLER_NAME " format");\r
1046\r
1047 /* Find the corresponding table entry */\r
1048 opinfo = find_opcode(oper_name, oper_size, oper_spec_proc, oper_spec_ea);\r
1049 if(opinfo == NULL)\r
1050 error_exit("Unable to find matching table entry for %s", func_name);\r
1051\r
1052#if 1 /* PD hack: 000 only */\r
1053 if (opinfo->cpus[0] == UNSPECIFIED_CH)\r
1054 continue;\r
1055#endif\r
1056\r
1057 replace->length = 0;\r
1058\r
1059 /* Generate opcode variants */\r
1060 if(strcmp(opinfo->name, "bcc") == 0 || strcmp(opinfo->name, "scc") == 0)\r
1061 generate_opcode_cc_variants(filep, body, replace, opinfo, 1);\r
1062 else if(strcmp(opinfo->name, "dbcc") == 0)\r
1063 generate_opcode_cc_variants(filep, body, replace, opinfo, 2);\r
1064 else if(strcmp(opinfo->name, "trapcc") == 0)\r
1065 generate_opcode_cc_variants(filep, body, replace, opinfo, 4);\r
1066 else\r
1067 generate_opcode_ea_variants(filep, body, replace, opinfo);\r
1068 }\r
1069\r
1070 free(replace);\r
1071 free(body);\r
1072}\r
1073\r
1074\r
1075/* Populate the opcode handler table from the input file */\r
1076void populate_table(void)\r
1077{\r
1078 char* ptr;\r
1079 char bitpattern[17];\r
1080 opcode_struct* op;\r
1081 char buff[MAX_LINE_LENGTH];\r
1082 int i;\r
1083 int temp;\r
1084\r
1085 buff[0] = 0;\r
1086\r
1087 /* Find the start of the table */\r
1088 while(strcmp(buff, ID_TABLE_START) != 0)\r
1089 if(fgetline(buff, MAX_LINE_LENGTH, g_input_file) < 0)\r
1090 error_exit("Premature EOF while reading table");\r
1091\r
1092 /* Process the entire table */\r
1093 for(op = g_opcode_input_table;;op++)\r
1094 {\r
1095 if(fgetline(buff, MAX_LINE_LENGTH, g_input_file) < 0)\r
1096 error_exit("Premature EOF while reading table");\r
1097 if(strlen(buff) == 0)\r
1098 continue;\r
1099 /* We finish when we find an input separator */\r
1100 if(strcmp(buff, ID_INPUT_SEPARATOR) == 0)\r
1101 break;\r
1102\r
1103 /* Extract the info from the table */\r
1104 ptr = buff;\r
1105\r
1106 /* Name */\r
1107 ptr += skip_spaces(ptr);\r
1108 ptr += check_strsncpy(op->name, ptr, MAX_NAME_LENGTH);\r
1109\r
1110 /* Size */\r
1111 ptr += skip_spaces(ptr);\r
1112 ptr += check_atoi(ptr, &temp);\r
1113 op->size = (unsigned char)temp;\r
1114\r
1115 /* Special processing */\r
1116 ptr += skip_spaces(ptr);\r
1117 ptr += check_strsncpy(op->spec_proc, ptr, MAX_SPEC_PROC_LENGTH);\r
1118\r
1119 /* Specified EA Mode */\r
1120 ptr += skip_spaces(ptr);\r
1121 ptr += check_strsncpy(op->spec_ea, ptr, MAX_SPEC_EA_LENGTH);\r
1122\r
1123 /* Bit Pattern (more processing later) */\r
1124 ptr += skip_spaces(ptr);\r
1125 ptr += check_strsncpy(bitpattern, ptr, 17);\r
1126\r
1127 /* Allowed Addressing Mode List */\r
1128 ptr += skip_spaces(ptr);\r
1129 ptr += check_strsncpy(op->ea_allowed, ptr, EA_ALLOWED_LENGTH);\r
1130\r
1131 /* CPU operating mode (U = user or supervisor, S = supervisor only */\r
1132 ptr += skip_spaces(ptr);\r
1133 for(i=0;i<NUM_CPUS;i++)\r
1134 {\r
1135 op->cpu_mode[i] = *ptr++;\r
1136 ptr += skip_spaces(ptr);\r
1137 }\r
1138\r
1139 /* Allowed CPUs for this instruction */\r
1140 for(i=0;i<NUM_CPUS;i++)\r
1141 {\r
1142 ptr += skip_spaces(ptr);\r
1143 if(*ptr == UNSPECIFIED_CH)\r
1144 {\r
1145 op->cpus[i] = UNSPECIFIED_CH;\r
1146 op->cycles[i] = 0;\r
1147 ptr++;\r
1148 }\r
1149 else\r
1150 {\r
1151 op->cpus[i] = '0' + i;\r
1152 ptr += check_atoi(ptr, &temp);\r
1153 op->cycles[i] = (unsigned char)temp;\r
1154 }\r
1155 }\r
1156\r
1157 /* generate mask and match from bitpattern */\r
1158 op->op_mask = 0;\r
1159 op->op_match = 0;\r
1160 for(i=0;i<16;i++)\r
1161 {\r
1162 op->op_mask |= (bitpattern[i] != '.') << (15-i);\r
1163 op->op_match |= (bitpattern[i] == '1') << (15-i);\r
1164 }\r
1165 }\r
1166 /* Terminate the list */\r
1167 op->name[0] = 0;\r
1168}\r
1169\r
1170/* Read a header or footer insert from the input file */\r
1171void read_insert(char* insert)\r
1172{\r
1173 char* ptr = insert;\r
1174 char* overflow = insert + MAX_INSERT_LENGTH - MAX_LINE_LENGTH;\r
1175 int length;\r
1176 char* first_blank = NULL;\r
1177\r
1178 first_blank = NULL;\r
1179\r
1180 /* Skip any leading blank lines */\r
1181 for(length = 0;length == 0;length = fgetline(ptr, MAX_LINE_LENGTH, g_input_file))\r
1182 if(ptr >= overflow)\r
1183 error_exit("Buffer overflow reading inserts");\r
1184 if(length < 0)\r
1185 error_exit("Premature EOF while reading inserts");\r
1186\r
1187 /* Advance and append newline */\r
1188 ptr += length;\r
1189 strcpy(ptr++, "\n");\r
1190\r
1191 /* Read until next separator */\r
1192 for(;;)\r
1193 {\r
1194 /* Read a new line */\r
1195 if(ptr >= overflow)\r
1196 error_exit("Buffer overflow reading inserts");\r
1197 if((length = fgetline(ptr, MAX_LINE_LENGTH, g_input_file)) < 0)\r
1198 error_exit("Premature EOF while reading inserts");\r
1199\r
1200 /* Stop if we read a separator */\r
1201 if(strcmp(ptr, ID_INPUT_SEPARATOR) == 0)\r
1202 break;\r
1203\r
1204 /* keep track in case there are trailing blanks */\r
1205 if(length == 0)\r
1206 {\r
1207 if(first_blank == NULL)\r
1208 first_blank = ptr;\r
1209 }\r
1210 else\r
1211 first_blank = NULL;\r
1212\r
1213 /* Advance and append newline */\r
1214 ptr += length;\r
1215 strcpy(ptr++, "\n");\r
1216 }\r
1217\r
1218 /* kill any trailing blank lines */\r
1219 if(first_blank)\r
1220 ptr = first_blank;\r
1221 *ptr++ = 0;\r
1222}\r
1223\r
1224\r
1225\r
1226/* ======================================================================== */\r
1227/* ============================= MAIN FUNCTION ============================ */\r
1228/* ======================================================================== */\r
1229\r
1230int main(int argc, char **argv)\r
1231{\r
1232 /* File stuff */\r
1233 char output_path[M68K_MAX_DIR] = "";\r
1234 char filename[M68K_MAX_PATH];\r
1235 /* Section identifier */\r
1236 char section_id[MAX_LINE_LENGTH+1];\r
1237 /* Inserts */\r
1238 char temp_insert[MAX_INSERT_LENGTH+1];\r
1239 char prototype_footer_insert[MAX_INSERT_LENGTH+1];\r
1240 char table_header_insert[MAX_INSERT_LENGTH+1];\r
1241 char table_footer_insert[MAX_INSERT_LENGTH+1];\r
1242 char ophandler_header_insert[MAX_INSERT_LENGTH+1];\r
1243 char ophandler_footer_insert[MAX_INSERT_LENGTH+1];\r
1244 /* Flags if we've processed certain parts already */\r
1245 int prototype_header_read = 0;\r
1246 int prototype_footer_read = 0;\r
1247 int table_header_read = 0;\r
1248 int table_footer_read = 0;\r
1249 int ophandler_header_read = 0;\r
1250 int ophandler_footer_read = 0;\r
1251 int table_body_read = 0;\r
1252 int ophandler_body_read = 0;\r
1253\r
1254 printf("\n\tMusashi v%s 68000, 68008, 68010, 68EC020, 68020, 68040 emulator\n", g_version);\r
1255 printf("\tCopyright 1998-2007 Karl Stenerud (karl@mame.net)\n\n");\r
1256\r
1257 /* Check if output path and source for the input file are given */\r
1258 if(argc > 1)\r
1259 {\r
1260 char *ptr;\r
1261 strcpy(output_path, argv[1]);\r
1262\r
1263 for(ptr = strchr(output_path, '\\'); ptr; ptr = strchr(ptr, '\\'))\r
1264 *ptr = '/';\r
1265\r
1266#if !(defined(__DECC) && defined(VMS))\r
1267 if(output_path[strlen(output_path)-1] != '/')\r
1268 strcat(output_path, "/");\r
1269#endif\r
1270\r
1271 if(argc > 2)\r
1272 strcpy(g_input_filename, argv[2]);\r
1273 }\r
1274\r
1275\r
1276#if defined(__DECC) && defined(VMS)\r
1277\r
1278 /* Open the files we need */\r
1279 sprintf(filename, "%s%s", output_path, FILENAME_PROTOTYPE);\r
1280 if((g_prototype_file = fopen(filename, "w")) == NULL)\r
1281 perror_exit("Unable to create prototype file (%s)\n", filename);\r
1282\r
1283 sprintf(filename, "%s%s", output_path, FILENAME_TABLE);\r
1284 if((g_table_file = fopen(filename, "w")) == NULL)\r
1285 perror_exit("Unable to create table file (%s)\n", filename);\r
1286\r
1287 if((g_input_file=fopen(g_input_filename, "r")) == NULL)\r
1288 perror_exit("can't open %s for input", g_input_filename);\r
1289\r
1290#else\r
1291\r
1292\r
1293 /* Open the files we need */\r
1294 sprintf(filename, "%s%s", output_path, FILENAME_PROTOTYPE);\r
1295 if((g_prototype_file = fopen(filename, "wt")) == NULL)\r
1296 perror_exit("Unable to create prototype file (%s)\n", filename);\r
1297\r
1298 sprintf(filename, "%s%s", output_path, FILENAME_TABLE);\r
1299 if((g_table_file = fopen(filename, "wt")) == NULL)\r
1300 perror_exit("Unable to create table file (%s)\n", filename);\r
1301\r
1302 if((g_input_file=fopen(g_input_filename, "rt")) == NULL)\r
1303 perror_exit("can't open %s for input", g_input_filename);\r
1304\r
1305#endif\r
1306\r
1307 /* Get to the first section of the input file */\r
1308 section_id[0] = 0;\r
1309 while(strcmp(section_id, ID_INPUT_SEPARATOR) != 0)\r
1310 if(fgetline(section_id, MAX_LINE_LENGTH, g_input_file) < 0)\r
1311 error_exit("Premature EOF while reading input file");\r
1312\r
1313 /* Now process all sections */\r
1314 for(;;)\r
1315 {\r
1316 if(fgetline(section_id, MAX_LINE_LENGTH, g_input_file) < 0)\r
1317 error_exit("Premature EOF while reading input file");\r
1318 if(strcmp(section_id, ID_PROTOTYPE_HEADER) == 0)\r
1319 {\r
1320 if(prototype_header_read)\r
1321 error_exit("Duplicate prototype header");\r
1322 read_insert(temp_insert);\r
1323 fprintf(g_prototype_file, "%s\n\n", temp_insert);\r
1324 prototype_header_read = 1;\r
1325 }\r
1326 else if(strcmp(section_id, ID_TABLE_HEADER) == 0)\r
1327 {\r
1328 if(table_header_read)\r
1329 error_exit("Duplicate table header");\r
1330 read_insert(table_header_insert);\r
1331 table_header_read = 1;\r
1332 }\r
1333 else if(strcmp(section_id, ID_OPHANDLER_HEADER) == 0)\r
1334 {\r
1335 if(ophandler_header_read)\r
1336 error_exit("Duplicate opcode handler header");\r
1337 read_insert(ophandler_header_insert);\r
1338 ophandler_header_read = 1;\r
1339 }\r
1340 else if(strcmp(section_id, ID_PROTOTYPE_FOOTER) == 0)\r
1341 {\r
1342 if(prototype_footer_read)\r
1343 error_exit("Duplicate prototype footer");\r
1344 read_insert(prototype_footer_insert);\r
1345 prototype_footer_read = 1;\r
1346 }\r
1347 else if(strcmp(section_id, ID_TABLE_FOOTER) == 0)\r
1348 {\r
1349 if(table_footer_read)\r
1350 error_exit("Duplicate table footer");\r
1351 read_insert(table_footer_insert);\r
1352 table_footer_read = 1;\r
1353 }\r
1354 else if(strcmp(section_id, ID_OPHANDLER_FOOTER) == 0)\r
1355 {\r
1356 if(ophandler_footer_read)\r
1357 error_exit("Duplicate opcode handler footer");\r
1358 read_insert(ophandler_footer_insert);\r
1359 ophandler_footer_read = 1;\r
1360 }\r
1361 else if(strcmp(section_id, ID_TABLE_BODY) == 0)\r
1362 {\r
1363 if(!prototype_header_read)\r
1364 error_exit("Table body encountered before prototype header");\r
1365 if(!table_header_read)\r
1366 error_exit("Table body encountered before table header");\r
1367 if(!ophandler_header_read)\r
1368 error_exit("Table body encountered before opcode handler header");\r
1369\r
1370 if(table_body_read)\r
1371 error_exit("Duplicate table body");\r
1372\r
1373 populate_table();\r
1374 table_body_read = 1;\r
1375 }\r
1376 else if(strcmp(section_id, ID_OPHANDLER_BODY) == 0)\r
1377 {\r
1378 if(!prototype_header_read)\r
1379 error_exit("Opcode handlers encountered before prototype header");\r
1380 if(!table_header_read)\r
1381 error_exit("Opcode handlers encountered before table header");\r
1382 if(!ophandler_header_read)\r
1383 error_exit("Opcode handlers encountered before opcode handler header");\r
1384 if(!table_body_read)\r
1385 error_exit("Opcode handlers encountered before table body");\r
1386\r
1387 if(ophandler_body_read)\r
1388 error_exit("Duplicate opcode handler section");\r
1389\r
1390 fprintf(g_table_file, "%s\n\n", ophandler_header_insert);\r
1391 process_opcode_handlers(g_table_file);\r
1392 fprintf(g_table_file, "%s\n\n", ophandler_footer_insert);\r
1393\r
1394 ophandler_body_read = 1;\r
1395 }\r
1396 else if(strcmp(section_id, ID_END) == 0)\r
1397 {\r
1398 /* End of input file. Do a sanity check and then write footers */\r
1399 if(!prototype_header_read)\r
1400 error_exit("Missing prototype header");\r
1401 if(!prototype_footer_read)\r
1402 error_exit("Missing prototype footer");\r
1403 if(!table_header_read)\r
1404 error_exit("Missing table header");\r
1405 if(!table_footer_read)\r
1406 error_exit("Missing table footer");\r
1407 if(!table_body_read)\r
1408 error_exit("Missing table body");\r
1409 if(!ophandler_header_read)\r
1410 error_exit("Missing opcode handler header");\r
1411 if(!ophandler_footer_read)\r
1412 error_exit("Missing opcode handler footer");\r
1413 if(!ophandler_body_read)\r
1414 error_exit("Missing opcode handler body");\r
1415\r
1416 fprintf(g_table_file, "%s\n\n", table_header_insert);\r
1417 print_opcode_output_table(g_table_file);\r
1418 fprintf(g_table_file, "%s\n\n", table_footer_insert);\r
1419\r
1420 fprintf(g_prototype_file, "%s\n\n", prototype_footer_insert);\r
1421\r
1422 break;\r
1423 }\r
1424 else\r
1425 {\r
1426 error_exit("Unknown section identifier: %s", section_id);\r
1427 }\r
1428 }\r
1429\r
1430 /* Close all files and exit */\r
1431 fclose(g_prototype_file);\r
1432 fclose(g_table_file);\r
1433 fclose(g_input_file);\r
1434\r
1435 printf("Generated %d opcode handlers from %d primitives\n", g_num_functions, g_num_primitives);\r
1436\r
1437 return 0;\r
1438}\r
1439\r
1440\r
1441\r
1442/* ======================================================================== */\r
1443/* ============================== END OF FILE ============================= */\r
1444/* ======================================================================== */\r
fast MegaDrive/MegaCD/32X emulator