OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [branches/] [oc/] [gdb-5.0/] [sim/] [igen/] [gen-engine.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.