]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - sim/igen/gen-engine.c
projects / thirdparty / binutils-gdb.git / blob
? search:


4b687c036afb6dd58f94062a17ac2f051cabe472
[thirdparty/binutils-gdb.git] / sim / igen / gen-engine.c
1 /* The IGEN simulator generator for GDB, the GNU Debugger.
2
3 Copyright 2002, 2007 Free Software Foundation, Inc.
4
5 Contributed by Andrew Cagney.
6
7 This file is part of GDB.
8
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
13
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
23
24 #include "misc.h"
25 #include "lf.h"
26 #include "table.h"
27 #include "filter.h"
28
29 #include "igen.h"
30
31 #include "ld-insn.h"
32 #include "ld-decode.h"
33
34 #include "gen.h"
35
36 #include "gen-idecode.h"
37 #include "gen-engine.h"
38 #include "gen-icache.h"
39 #include "gen-semantics.h"
40
41
42 static void
43 print_engine_issue_prefix_hook (lf *file)
44 {
45 lf_printf (file, "\n");
46 lf_indent_suppress (file);
47 lf_printf (file, "#if defined (ENGINE_ISSUE_PREFIX_HOOK)\n");
48 lf_printf (file, "ENGINE_ISSUE_PREFIX_HOOK();\n");
49 lf_indent_suppress (file);
50 lf_printf (file, "#endif\n");
51 lf_printf (file, "\n");
52 }
53
54 static void
55 print_engine_issue_postfix_hook (lf *file)
56 {
57 lf_printf (file, "\n");
58 lf_indent_suppress (file);
59 lf_printf (file, "#if defined (ENGINE_ISSUE_POSTFIX_HOOK)\n");
60 lf_printf (file, "ENGINE_ISSUE_POSTFIX_HOOK();\n");
61 lf_indent_suppress (file);
62 lf_printf (file, "#endif\n");
63 lf_printf (file, "\n");
64 }
65
66
67 static void
68 print_run_body (lf *file, gen_entry *table)
69 {
70 /* Output the function to execute real code:
71
72 Unfortunatly, there are multiple cases to consider vis:
73
74 <icache> X <smp>
75
76 Consequently this function is written in multiple different ways */
77
78 lf_printf (file, "{\n");
79 lf_indent (file, +2);
80 if (!options.gen.smp)
81 {
82 lf_printf (file, "%sinstruction_address cia;\n",
83 options.module.global.prefix.l);
84 }
85 lf_printf (file, "int current_cpu = next_cpu_nr;\n");
86
87 if (options.gen.icache)
88 {
89 lf_printf (file, "/* flush the icache of a possible break insn */\n");
90 lf_printf (file, "{\n");
91 lf_printf (file, " int cpu_nr;\n");
92 lf_printf (file, " for (cpu_nr = 0; cpu_nr < nr_cpus; cpu_nr++)\n");
93 lf_printf (file, " cpu_flush_icache (STATE_CPU (sd, cpu_nr));\n");
94 lf_printf (file, "}\n");
95 }
96
97 if (!options.gen.smp)
98 {
99
100 lf_putstr (file, "\
101 /* CASE 1: NO SMP (with or with out instruction cache).\n\
102 \n\
103 In this case, we can take advantage of the fact that the current\n\
104 instruction address (CIA) does not need to be read from / written to\n\
105 the CPU object after the execution of an instruction.\n\
106 \n\
107 Instead, CIA is only saved when the main loop exits. This occures\n\
108 when either sim_engine_halt or sim_engine_restart is called. Both of\n\
109 these functions save the current instruction address before halting /\n\
110 restarting the simulator.\n\
111 \n\
112 As a variation, there may also be support for an instruction cracking\n\
113 cache. */\n\
114 \n\
115 ");
116
117 lf_putstr (file, "\n");
118 lf_putstr (file, "/* prime the main loop */\n");
119 lf_putstr (file, "SIM_ASSERT (current_cpu == 0);\n");
120 lf_putstr (file, "SIM_ASSERT (nr_cpus == 1);\n");
121 lf_putstr (file, "cia = CIA_GET (CPU);\n");
122
123 lf_putstr (file, "\n");
124 lf_putstr (file, "while (1)\n");
125 lf_putstr (file, " {\n");
126 lf_indent (file, +4);
127
128 lf_printf (file, "%sinstruction_address nia;\n",
129 options.module.global.prefix.l);
130
131 lf_printf (file, "\n");
132 if (!options.gen.icache)
133 {
134 lf_printf (file,
135 "%sinstruction_word instruction_0 = IMEM%d (cia);\n",
136 options.module.global.prefix.l, options.insn_bit_size);
137 print_engine_issue_prefix_hook (file);
138 print_idecode_body (file, table, "nia = ");
139 print_engine_issue_postfix_hook (file);
140 }
141 else
142 {
143 lf_putstr (file, "idecode_cache *cache_entry =\n");
144 lf_putstr (file, " cpu_icache_entry (cpu, cia);\n");
145 lf_putstr (file, "if (cache_entry->address == cia)\n");
146 lf_putstr (file, " {\n");
147 lf_indent (file, -4);
148 lf_putstr (file, "/* cache hit */\n");
149 lf_putstr (file,
150 "idecode_semantic *const semantic = cache_entry->semantic;\n");
151 lf_putstr (file, "cia = semantic (cpu, cache_entry, cia);\n");
152 /* tail */
153 lf_indent (file, -4);
154 lf_putstr (file, " }\n");
155 lf_putstr (file, "else\n");
156 lf_putstr (file, " {\n");
157 lf_indent (file, +4);
158 lf_putstr (file, "/* cache miss */\n");
159 if (!options.gen.semantic_icache)
160 {
161 lf_putstr (file, "idecode_semantic *semantic;\n");
162 }
163 lf_printf (file, "instruction_word instruction = IMEM%d (cia);\n",
164 options.insn_bit_size);
165 lf_putstr (file, "if (WITH_MON != 0)\n");
166 lf_putstr (file,
167 " mon_event (mon_event_icache_miss, cpu, cia);\n");
168 if (options.gen.semantic_icache)
169 {
170 lf_putstr (file, "{\n");
171 lf_indent (file, +2);
172 print_engine_issue_prefix_hook (file);
173 print_idecode_body (file, table, "nia =");
174 print_engine_issue_postfix_hook (file);
175 lf_indent (file, -2);
176 lf_putstr (file, "}\n");
177 }
178 else
179 {
180 print_engine_issue_prefix_hook (file);
181 print_idecode_body (file, table, "semantic =");
182 lf_putstr (file, "nia = semantic (cpu, cache_entry, cia);\n");
183 print_engine_issue_postfix_hook (file);
184 }
185 lf_indent (file, -4);
186 lf_putstr (file, " }\n");
187 }
188
189 /* update the cpu if necessary */
190 switch (options.gen.nia)
191 {
192 case nia_is_cia_plus_one:
193 lf_printf (file, "\n");
194 lf_printf (file, "/* Update the instruction address */\n");
195 lf_printf (file, "cia = nia;\n");
196 break;
197 case nia_is_void:
198 case nia_is_invalid:
199 ERROR ("engine gen when NIA complex");
200 }
201
202 /* events */
203 lf_putstr (file, "\n");
204 lf_putstr (file, "/* process any events */\n");
205 lf_putstr (file, "if (sim_events_tick (sd))\n");
206 lf_putstr (file, " {\n");
207 lf_putstr (file, " CIA_SET (CPU, cia);\n");
208 lf_putstr (file, " sim_events_process (sd);\n");
209 lf_putstr (file, " cia = CIA_GET (CPU);\n");
210 lf_putstr (file, " }\n");
211
212 lf_indent (file, -4);
213 lf_printf (file, " }\n");
214 }
215
216 if (options.gen.smp)
217 {
218
219 lf_putstr (file, "\
220 /* CASE 2: SMP (With or without ICACHE)\n\
221 \n\
222 The complexity here comes from needing to correctly halt the simulator\n\
223 when it is aborted. For instance, if cpu0 requests a restart then\n\
224 cpu1 will normally be the next cpu that is run. Cpu0 being restarted\n\
225 after all the other CPU's and the event queue have been processed */\n\
226 \n\
227 ");
228
229 lf_putstr (file, "\n");
230 lf_printf (file,
231 "/* have ensured that the event queue is NOT next */\n");
232 lf_printf (file, "SIM_ASSERT (current_cpu >= 0);\n");
233 lf_printf (file, "SIM_ASSERT (current_cpu <= nr_cpus - 1);\n");
234 lf_printf (file, "SIM_ASSERT (nr_cpus <= MAX_NR_PROCESSORS);\n");
235
236 lf_putstr (file, "\n");
237 lf_putstr (file, "while (1)\n");
238 lf_putstr (file, " {\n");
239 lf_indent (file, +4);
240 lf_putstr (file, "sim_cpu *cpu = STATE_CPU (sd, current_cpu);\n");
241 lf_putstr (file, "instruction_address cia = CIA_GET (cpu);\n");
242 lf_putstr (file, "\n");
243
244 if (!options.gen.icache)
245 {
246 lf_printf (file, "instruction_word instruction_0 = IMEM%d (cia);\n",
247 options.insn_bit_size);
248 print_engine_issue_prefix_hook (file);
249 print_idecode_body (file, table, "cia =");
250 lf_putstr (file, "CIA_SET (cpu, cia);\n");
251 print_engine_issue_postfix_hook (file);
252 }
253
254 if (options.gen.icache)
255 {
256 lf_putstr (file, "engine_cache *cache_entry =\n");
257 lf_putstr (file, " cpu_icache_entry(processor, cia);\n");
258 lf_putstr (file, "\n");
259 lf_putstr (file, "if (cache_entry->address == cia) {\n");
260 {
261 lf_indent (file, +2);
262 lf_putstr (file, "\n");
263 lf_putstr (file, "/* cache hit */\n");
264 lf_putstr (file,
265 "engine_semantic *semantic = cache_entry->semantic;\n");
266 lf_putstr (file,
267 "cia = semantic(processor, cache_entry, cia);\n");
268 /* tail */
269 lf_putstr (file, "cpu_set_program_counter(processor, cia);\n");
270 lf_putstr (file, "\n");
271 lf_indent (file, -2);
272 }
273 lf_putstr (file, "}\n");
274 lf_putstr (file, "else {\n");
275 {
276 lf_indent (file, +2);
277 lf_putstr (file, "\n");
278 lf_putstr (file, "/* cache miss */\n");
279 if (!options.gen.semantic_icache)
280 {
281 lf_putstr (file, "engine_semantic *semantic;\n");
282 }
283 lf_printf (file, "instruction_word instruction = IMEM%d (cia);\n",
284 options.insn_bit_size);
285 lf_putstr (file, "if (WITH_MON != 0)\n");
286 lf_putstr (file,
287 " mon_event(mon_event_icache_miss, processors[current_cpu], cia);\n");
288 if (options.gen.semantic_icache)
289 {
290 lf_putstr (file, "{\n");
291 lf_indent (file, +2);
292 print_engine_issue_prefix_hook (file);
293 print_idecode_body (file, table, "cia =");
294 print_engine_issue_postfix_hook (file);
295 lf_indent (file, -2);
296 lf_putstr (file, "}\n");
297 }
298 else
299 {
300 print_engine_issue_prefix_hook (file);
301 print_idecode_body (file, table, "semantic = ");
302 lf_putstr (file,
303 "cia = semantic(processor, cache_entry, cia);\n");
304 print_engine_issue_postfix_hook (file);
305 }
306 /* tail */
307 lf_putstr (file, "cpu_set_program_counter(processor, cia);\n");
308 lf_putstr (file, "\n");
309 lf_indent (file, -2);
310 }
311 lf_putstr (file, "}\n");
312 }
313
314 lf_putstr (file, "\n");
315 lf_putstr (file, "current_cpu += 1;\n");
316 lf_putstr (file, "if (current_cpu == nr_cpus)\n");
317 lf_putstr (file, " {\n");
318 lf_putstr (file, " if (sim_events_tick (sd))\n");
319 lf_putstr (file, " {\n");
320 lf_putstr (file, " sim_events_process (sd);\n");
321 lf_putstr (file, " }\n");
322 lf_putstr (file, " current_cpu = 0;\n");
323 lf_putstr (file, " }\n");
324
325 /* tail */
326 lf_indent (file, -4);
327 lf_putstr (file, " }\n");
328 }
329
330
331 lf_indent (file, -2);
332 lf_putstr (file, "}\n");
333 }
334
335
336 /****************************************************************/
337
338 #if 0
339 static void
340 print_jump (lf *file, int is_tail)
341 {
342 if (!options.gen.smp)
343 {
344 lf_putstr (file, "if (event_queue_tick (sd))\n");
345 lf_putstr (file, " {\n");
346 lf_putstr (file, " CPU_CIA (processor) = nia;\n");
347 lf_putstr (file, " sim_events_process (sd);\n");
348 lf_putstr (file, " }\n");
349 lf_putstr (file, "}\n");
350 }
351
352 if (options.gen.smp)
353 {
354 if (is_tail)
355 lf_putstr (file, "cpu_set_program_counter(processor, nia);\n");
356 lf_putstr (file, "current_cpu += 1;\n");
357 lf_putstr (file, "if (current_cpu >= nr_cpus)\n");
358 lf_putstr (file, " {\n");
359 lf_putstr (file, " if (sim_events_tick (sd))\n");
360 lf_putstr (file, " {\n");
361 lf_putstr (file, " sim_events_process (sd);\n");
362 lf_putstr (file, " }\n");
363 lf_putstr (file, " current_cpu = 0;\n");
364 lf_putstr (file, " }\n");
365 lf_putstr (file, "processor = processors[current_cpu];\n");
366 lf_putstr (file, "nia = cpu_get_program_counter(processor);\n");
367 }
368
369 if (options.gen.icache)
370 {
371 lf_putstr (file, "cache_entry = cpu_icache_entry(processor, nia);\n");
372 lf_putstr (file, "if (cache_entry->address == nia) {\n");
373 lf_putstr (file, " /* cache hit */\n");
374 lf_putstr (file, " goto *cache_entry->semantic;\n");
375 lf_putstr (file, "}\n");
376 if (is_tail)
377 {
378 lf_putstr (file, "goto cache_miss;\n");
379 }
380 }
381
382 if (!options.gen.icache && is_tail)
383 {
384 lf_printf (file, "goto engine;\n");
385 }
386
387 }
388 #endif
389
390
391 #if 0
392 static void
393 print_jump_insn (lf *file,
394 insn_entry * instruction,
395 opcode_bits *expanded_bits,
396 opcode_field *opcodes, cache_entry *cache_rules)
397 {
398 insn_opcodes opcode_path;
399
400 memset (&opcode_path, 0, sizeof (opcode_path));
401 opcode_path.opcode = opcodes;
402
403 /* what we are for the moment */
404 lf_printf (file, "\n");
405 print_my_defines (file,
406 instruction->name,
407 instruction->format_name, expanded_bits);
408
409 /* output the icache entry */
410 if (options.gen.icache)
411 {
412 lf_printf (file, "\n");
413 lf_indent (file, -1);
414 print_function_name (file,
415 instruction->name,
416 instruction->format_name,
417 NULL, expanded_bits, function_name_prefix_icache);
418 lf_printf (file, ":\n");
419 lf_indent (file, +1);
420 lf_printf (file, "{\n");
421 lf_indent (file, +2);
422 lf_putstr (file, "const unsigned_word cia = nia;\n");
423 print_itrace (file, instruction, 1 /*putting-value-in-cache */ );
424 print_idecode_validate (file, instruction, &opcode_path);
425 lf_printf (file, "\n");
426 lf_printf (file, "{\n");
427 lf_indent (file, +2);
428 print_icache_body (file, instruction, expanded_bits, cache_rules, 0, /*use_defines */
429 put_values_in_icache);
430 lf_printf (file, "cache_entry->address = nia;\n");
431 lf_printf (file, "cache_entry->semantic = &&");
432 print_function_name (file,
433 instruction->name,
434 instruction->format_name,
435 NULL,
436 expanded_bits, function_name_prefix_semantics);
437 lf_printf (file, ";\n");
438 if (options.gen.semantic_icache)
439 {
440 print_semantic_body (file,
441 instruction, expanded_bits, &opcode_path);
442 print_jump (file, 1 /*is-tail */ );
443 }
444 else
445 {
446 lf_printf (file, "/* goto ");
447 print_function_name (file,
448 instruction->name,
449 instruction->format_name,
450 NULL,
451 expanded_bits, function_name_prefix_semantics);
452 lf_printf (file, "; */\n");
453 }
454 lf_indent (file, -2);
455 lf_putstr (file, "}\n");
456 lf_indent (file, -2);
457 lf_printf (file, "}\n");
458 }
459
460 /* print the semantics */
461 lf_printf (file, "\n");
462 lf_indent (file, -1);
463 print_function_name (file,
464 instruction->name,
465 instruction->format_name,
466 NULL, expanded_bits, function_name_prefix_semantics);
467 lf_printf (file, ":\n");
468 lf_indent (file, +1);
469 lf_printf (file, "{\n");
470 lf_indent (file, +2);
471 lf_putstr (file, "const unsigned_word cia = nia;\n");
472 print_icache_body (file,
473 instruction,
474 expanded_bits,
475 cache_rules,
476 (options.gen.direct_access
477 ? define_variables
478 : declare_variables),
479 (options.gen.icache
480 ? get_values_from_icache : do_not_use_icache));
481 print_semantic_body (file, instruction, expanded_bits, &opcode_path);
482 if (options.gen.direct_access)
483 print_icache_body (file,
484 instruction,
485 expanded_bits,
486 cache_rules,
487 undef_variables,
488 (options.gen.icache
489 ? get_values_from_icache : do_not_use_icache));
490 print_jump (file, 1 /*is tail */ );
491 lf_indent (file, -2);
492 lf_printf (file, "}\n");
493 }
494 #endif
495
496
497 #if 0
498 static void
499 print_jump_definition (lf *file, gen_entry *entry, int depth, void *data)
500 {
501 cache_entry *cache_rules = (cache_entry *) data;
502 if (entry->opcode_rule->with_duplicates)
503 {
504 ASSERT (entry->nr_insns == 1
505 && entry->opcode == NULL
506 && entry->parent != NULL && entry->parent->opcode != NULL);
507 ASSERT (entry->nr_insns == 1
508 && entry->opcode == NULL
509 && entry->parent != NULL
510 && entry->parent->opcode != NULL
511 && entry->parent->opcode_rule != NULL);
512 print_jump_insn (file,
513 entry->insns->insn,
514 entry->expanded_bits, entry->opcode, cache_rules);
515 }
516 else
517 {
518 print_jump_insn (file, entry->insns->insn, NULL, NULL, cache_rules);
519 }
520 }
521 #endif
522
523
524 #if 0
525 static void
526 print_jump_internal_function (lf *file, function_entry * function, void *data)
527 {
528 if (function->is_internal)
529 {
530 lf_printf (file, "\n");
531 lf_print__line_ref (file, function->line);
532 lf_indent (file, -1);
533 print_function_name (file,
534 function->name,
535 NULL,
536 NULL,
537 NULL,
538 (options.gen.icache
539 ? function_name_prefix_icache
540 : function_name_prefix_semantics));
541 lf_printf (file, ":\n");
542 lf_indent (file, +1);
543 lf_printf (file, "{\n");
544 lf_indent (file, +2);
545 lf_printf (file, "const unsigned_word cia = nia;\n");
546 table_print_code (file, function->code);
547 lf_print__internal_ref (file);
548 lf_printf (file, "error(\"Internal function must longjump\\n\");\n");
549 lf_indent (file, -2);
550 lf_printf (file, "}\n");
551 }
552 }
553 #endif
554
555
556 #if 0
557 static void
558 print_jump_body (lf *file,
559 gen_entry *entry, insn_table *isa, cache_entry *cache_rules)
560 {
561 lf_printf (file, "{\n");
562 lf_indent (file, +2);
563 lf_putstr (file, "jmp_buf halt;\n");
564 lf_putstr (file, "jmp_buf restart;\n");
565 lf_putstr (file, "cpu *processor = NULL;\n");
566 lf_putstr (file, "unsigned_word nia = -1;\n");
567 lf_putstr (file, "instruction_word instruction = 0;\n");
568 if (options.gen.icache)
569 {
570 lf_putstr (file, "engine_cache *cache_entry = NULL;\n");
571 }
572 if (options.gen.smp)
573 {
574 lf_putstr (file, "int current_cpu = -1;\n");
575 }
576
577 /* all the switches and tables - they know about jumping */
578 print_idecode_lookups (file, entry, cache_rules);
579
580 /* start the simulation up */
581 if (options.gen.icache)
582 {
583 lf_putstr (file, "\n");
584 lf_putstr (file, "{\n");
585 lf_putstr (file, " int cpu_nr;\n");
586 lf_putstr (file, " for (cpu_nr = 0; cpu_nr < nr_cpus; cpu_nr++)\n");
587 lf_putstr (file, " cpu_flush_icache(processors[cpu_nr]);\n");
588 lf_putstr (file, "}\n");
589 }
590
591 lf_putstr (file, "\n");
592 lf_putstr (file, "psim_set_halt_and_restart(system, &halt, &restart);\n");
593
594 lf_putstr (file, "\n");
595 lf_putstr (file, "if (setjmp(halt))\n");
596 lf_putstr (file, " return;\n");
597
598 lf_putstr (file, "\n");
599 lf_putstr (file, "setjmp(restart);\n");
600
601 lf_putstr (file, "\n");
602 if (!options.gen.smp)
603 {
604 lf_putstr (file, "processor = processors[0];\n");
605 lf_putstr (file, "nia = cpu_get_program_counter(processor);\n");
606 }
607 else
608 {
609 lf_putstr (file, "current_cpu = psim_last_cpu(system);\n");
610 }
611
612 if (!options.gen.icache)
613 {
614 lf_printf (file, "\n");
615 lf_indent (file, -1);
616 lf_printf (file, "engine:\n");
617 lf_indent (file, +1);
618 }
619
620 print_jump (file, 0 /*is_tail */ );
621
622 if (options.gen.icache)
623 {
624 lf_indent (file, -1);
625 lf_printf (file, "cache_miss:\n");
626 lf_indent (file, +1);
627 }
628
629 print_engine_issue_prefix_hook (file);
630 lf_putstr (file, "instruction\n");
631 lf_putstr (file,
632 " = vm_instruction_map_read(cpu_instruction_map(processor),\n");
633 lf_putstr (file, " processor, nia);\n");
634 print_engine_issue_prefix_hook (file);
635 print_idecode_body (file, entry, "/*IGORE*/");
636 print_engine_issue_postfix_hook (file);
637
638 /* print out a table of all the internals functions */
639 function_entry_traverse (file, isa->functions,
640 print_jump_internal_function, NULL);
641
642 /* print out a table of all the instructions */
643 ERROR ("Use the list of semantic functions, not travere_tree");
644 gen_entry_traverse_tree (file, entry, 1, NULL, /* start */
645 print_jump_definition, /* leaf */
646 NULL, /* end */
647 cache_rules);
648 lf_indent (file, -2);
649 lf_printf (file, "}\n");
650 }
651 #endif
652
653
654 /****************************************************************/
655
656
657 void
658 print_engine_run_function_header (lf *file,
659 char *processor,
660 function_decl_type decl_type)
661 {
662 int indent;
663 lf_printf (file, "\n");
664 switch (decl_type)
665 {
666 case is_function_declaration:
667 lf_print__function_type (file, "void", "INLINE_ENGINE", "\n");
668 break;
669 case is_function_definition:
670 lf_print__function_type (file, "void", "INLINE_ENGINE", " ");
671 break;
672 case is_function_variable:
673 lf_printf (file, "void (*");
674 break;
675 }
676 indent = print_function_name (file, "run", NULL, /* format name */
677 processor, NULL, /* expanded bits */
678 function_name_prefix_engine);
679 switch (decl_type)
680 {
681 case is_function_definition:
682 lf_putstr (file, "\n(");
683 indent = 1;
684 break;
685 case is_function_declaration:
686 indent += lf_printf (file, " (");
687 break;
688 case is_function_variable:
689 lf_putstr (file, ")\n(");
690 indent = 1;
691 break;
692 }
693 lf_indent (file, +indent);
694 lf_printf (file, "SIM_DESC sd,\n");
695 lf_printf (file, "int next_cpu_nr,\n");
696 lf_printf (file, "int nr_cpus,\n");
697 lf_printf (file, "int siggnal)");
698 lf_indent (file, -indent);
699 switch (decl_type)
700 {
701 case is_function_definition:
702 lf_putstr (file, "\n");
703 break;
704 case is_function_variable:
705 case is_function_declaration:
706 lf_putstr (file, ";\n");
707 break;
708 }
709 }
710
711
712 void
713 gen_engine_h (lf *file,
714 gen_table *gen, insn_table *isa, cache_entry *cache_rules)
715 {
716 gen_list *entry;
717 for (entry = gen->tables; entry != NULL; entry = entry->next)
718 {
719 print_engine_run_function_header (file,
720 (options.gen.multi_sim
721 ? entry->model->name
722 : NULL), is_function_declaration);
723 }
724 }
725
726
727 void
728 gen_engine_c (lf *file,
729 gen_table *gen, insn_table *isa, cache_entry *cache_rules)
730 {
731 gen_list *entry;
732 /* the intro */
733 print_includes (file);
734 print_include_inline (file, options.module.semantics);
735 print_include (file, options.module.engine);
736 lf_printf (file, "\n");
737 lf_printf (file, "#include \"sim-assert.h\"\n");
738 lf_printf (file, "\n");
739 print_idecode_globals (file);
740 lf_printf (file, "\n");
741
742 for (entry = gen->tables; entry != NULL; entry = entry->next)
743 {
744 switch (options.gen.code)
745 {
746 case generate_calls:
747 print_idecode_lookups (file, entry->table, cache_rules);
748
749 /* output the main engine routine */
750 print_engine_run_function_header (file,
751 (options.gen.multi_sim
752 ? entry->model->name
753 : NULL), is_function_definition);
754 print_run_body (file, entry->table);
755 break;
756
757 case generate_jumps:
758 ERROR ("Jumps currently unimplemented");
759 #if 0
760 print_engine_run_function_header (file,
761 entry->processor,
762 is_function_definition);
763 print_jump_body (file, entry->table, isa, cache_rules);
764 #endif
765 break;
766 }
767 }
768 }
A mirror of the official binutils-gdb repository