3bc08ee2e49f7f940199f939a794182246907449
1 /* Simulator for the FT32 processor
3 Copyright (C) 2008-2017 Free Software Foundation, Inc.
4 Contributed by FTDI <support@ftdichip.com>
6 This file is part of simulators.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
28 #include "gdb/callback.h"
29 #include "libiberty.h"
30 #include "gdb/remote-sim.h"
33 #include "sim-options.h"
35 #include "opcode/ft32.h"
38 * FT32 is a Harvard architecture: RAM and code occupy
39 * different address spaces.
41 * sim and gdb model FT32 memory by adding 0x800000 to RAM
42 * addresses. This means that sim/gdb can treat all addresses
45 * The address space looks like:
47 * 00000 start of code memory
48 * 3ffff end of code memory
53 #define RAM_BIAS 0x800000 /* Bias added to RAM addresses. */
56 ft32_extract_unsigned_integer (unsigned char *addr
, int len
)
60 unsigned char *startaddr
= (unsigned char *) addr
;
61 unsigned char *endaddr
= startaddr
+ len
;
63 /* Start at the most significant end of the integer, and work towards
64 the least significant. */
67 for (p
= endaddr
; p
> startaddr
;)
68 retval
= (retval
<< 8) | * -- p
;
74 ft32_store_unsigned_integer (unsigned char *addr
, int len
, unsigned long val
)
77 unsigned char *startaddr
= (unsigned char *)addr
;
78 unsigned char *endaddr
= startaddr
+ len
;
80 for (p
= startaddr
; p
< endaddr
; p
++)
88 * Align EA according to its size DW.
89 * The FT32 ignores the low bit of a 16-bit addresss,
90 * and the low two bits of a 32-bit address.
92 static uint32_t ft32_align (uint32_t dw
, uint32_t ea
)
108 /* Read an item from memory address EA, sized DW. */
110 ft32_read_item (SIM_DESC sd
, int dw
, uint32_t ea
)
112 sim_cpu
*cpu
= STATE_CPU (sd
, 0);
113 address_word cia
= CPU_PC_GET (cpu
);
117 ea
= ft32_align (dw
, ea
);
121 return sim_core_read_aligned_1 (cpu
, cia
, read_map
, ea
);
123 return sim_core_read_aligned_2 (cpu
, cia
, read_map
, ea
);
125 return sim_core_read_aligned_4 (cpu
, cia
, read_map
, ea
);
131 /* Write item V to memory address EA, sized DW. */
133 ft32_write_item (SIM_DESC sd
, int dw
, uint32_t ea
, uint32_t v
)
135 sim_cpu
*cpu
= STATE_CPU (sd
, 0);
136 address_word cia
= CPU_PC_GET (cpu
);
139 ea
= ft32_align (dw
, ea
);
143 sim_core_write_aligned_1 (cpu
, cia
, write_map
, ea
, v
);
146 sim_core_write_aligned_2 (cpu
, cia
, write_map
, ea
, v
);
149 sim_core_write_aligned_4 (cpu
, cia
, write_map
, ea
, v
);
157 sim_engine_halt (sd, cpu, NULL, insnpc, sim_signalled, SIM_SIGILL)
159 static uint32_t cpu_mem_read (SIM_DESC sd
, uint32_t dw
, uint32_t ea
)
161 sim_cpu
*cpu
= STATE_CPU (sd
, 0);
162 uint32_t insnpc
= cpu
->state
.pc
;
169 /* Simulate some IO devices */
175 /* Read the simulator cycle timer. */
176 return cpu
->state
.cycles
/ 100;
178 sim_io_eprintf (sd
, "Illegal IO read address %08x, pc %#x\n",
183 return ft32_read_item (sd
, dw
, RAM_BIAS
+ ea
);
186 static void cpu_mem_write (SIM_DESC sd
, uint32_t dw
, uint32_t ea
, uint32_t d
)
188 sim_cpu
*cpu
= STATE_CPU (sd
, 0);
192 /* Simulate some IO devices */
200 /* Unlock the PM write port */
201 cpu
->state
.pm_unlock
= (d
== 0x1337f7d1);
204 /* Set the PM write address register */
205 cpu
->state
.pm_addr
= d
;
208 if (cpu
->state
.pm_unlock
)
211 ft32_write_item (sd
, dw
, cpu
->state
.pm_addr
, d
);
212 cpu
->state
.pm_addr
+= 4;
217 sim_engine_halt (sd
, cpu
, NULL
, cpu
->state
.pc
, sim_exited
, cpu
->state
.regs
[0]);
220 sim_io_printf (sd
, "Debug write %08x\n", d
);
223 sim_io_eprintf (sd
, "Unknown IO write %08x to to %08x\n", d
, ea
);
227 ft32_write_item (sd
, dw
, RAM_BIAS
+ ea
, d
);
230 #define GET_BYTE(ea) cpu_mem_read (sd, 0, (ea))
231 #define PUT_BYTE(ea, d) cpu_mem_write (sd, 0, (ea), (d))
233 /* LSBS (n) is a mask of the least significant N bits. */
234 #define LSBS(n) ((1U << (n)) - 1)
236 static void ft32_push (SIM_DESC sd
, uint32_t v
)
238 sim_cpu
*cpu
= STATE_CPU (sd
, 0);
239 cpu
->state
.regs
[FT32_HARD_SP
] -= 4;
240 cpu
->state
.regs
[FT32_HARD_SP
] &= 0xffff;
241 cpu_mem_write (sd
, 2, cpu
->state
.regs
[FT32_HARD_SP
], v
);
244 static uint32_t ft32_pop (SIM_DESC sd
)
246 sim_cpu
*cpu
= STATE_CPU (sd
, 0);
247 uint32_t r
= cpu_mem_read (sd
, 2, cpu
->state
.regs
[FT32_HARD_SP
]);
248 cpu
->state
.regs
[FT32_HARD_SP
] += 4;
249 cpu
->state
.regs
[FT32_HARD_SP
] &= 0xffff;
253 /* Extract the low SIZ bits of N as an unsigned number. */
254 static int nunsigned (int siz
, int n
)
256 return n
& LSBS (siz
);
259 /* Extract the low SIZ bits of N as a signed number. */
260 static int nsigned (int siz
, int n
)
262 int shift
= (sizeof (int) * 8) - siz
;
263 return (n
<< shift
) >> shift
;
266 /* Signed division N / D, matching hw behavior for (MIN_INT, -1). */
267 static uint32_t ft32sdiv (uint32_t n
, uint32_t d
)
269 if (n
== 0x80000000UL
&& d
== 0xffffffffUL
)
272 return (uint32_t)((int)n
/ (int)d
);
275 /* Signed modulus N % D, matching hw behavior for (MIN_INT, -1). */
276 static uint32_t ft32smod (uint32_t n
, uint32_t d
)
278 if (n
== 0x80000000UL
&& d
== 0xffffffffUL
)
281 return (uint32_t)((int)n
% (int)d
);
284 /* Circular rotate right N by B bits. */
285 static uint32_t ror (uint32_t n
, uint32_t b
)
288 return (n
>> b
) | (n
<< (32 - b
));
291 /* Implement the BINS machine instruction.
292 See FT32 Programmer's Reference for details. */
293 static uint32_t bins (uint32_t d
, uint32_t f
, uint32_t len
, uint32_t pos
)
295 uint32_t bitmask
= LSBS (len
) << pos
;
296 return (d
& ~bitmask
) | ((f
<< pos
) & bitmask
);
299 /* Implement the FLIP machine instruction.
300 See FT32 Programmer's Reference for details. */
301 static uint32_t flip (uint32_t x
, uint32_t b
)
304 x
= (x
& 0x55555555) << 1 | (x
& 0xAAAAAAAA) >> 1;
306 x
= (x
& 0x33333333) << 2 | (x
& 0xCCCCCCCC) >> 2;
308 x
= (x
& 0x0F0F0F0F) << 4 | (x
& 0xF0F0F0F0) >> 4;
310 x
= (x
& 0x00FF00FF) << 8 | (x
& 0xFF00FF00) >> 8;
312 x
= (x
& 0x0000FFFF) << 16 | (x
& 0xFFFF0000) >> 16;
317 step_once (SIM_DESC sd
)
319 sim_cpu
*cpu
= STATE_CPU (sd
, 0);
320 address_word cia
= CPU_PC_GET (cpu
);
344 if (cpu
->state
.cycles
>= cpu
->state
.next_tick_cycle
)
346 cpu
->state
.next_tick_cycle
+= 100000;
347 ft32_push (sd
, cpu
->state
.pc
);
348 cpu
->state
.pc
= 12; /* interrupt 1. */
350 inst
= ft32_read_item (sd
, 2, cpu
->state
.pc
);
351 cpu
->state
.cycles
+= 1;
353 /* Handle "call 8" (which is FT32's "break" equivalent) here. */
354 if (inst
== 0x00340002)
356 sim_engine_halt (sd
, cpu
, NULL
,
358 sim_stopped
, SIM_SIGTRAP
);
362 dw
= (inst
>> FT32_FLD_DW_BIT
) & LSBS (FT32_FLD_DW_SIZ
);
363 cb
= (inst
>> FT32_FLD_CB_BIT
) & LSBS (FT32_FLD_CB_SIZ
);
364 r_d
= (inst
>> FT32_FLD_R_D_BIT
) & LSBS (FT32_FLD_R_D_SIZ
);
365 cr
= (inst
>> FT32_FLD_CR_BIT
) & LSBS (FT32_FLD_CR_SIZ
);
366 cv
= (inst
>> FT32_FLD_CV_BIT
) & LSBS (FT32_FLD_CV_SIZ
);
367 bt
= (inst
>> FT32_FLD_BT_BIT
) & LSBS (FT32_FLD_BT_SIZ
);
368 r_1
= (inst
>> FT32_FLD_R_1_BIT
) & LSBS (FT32_FLD_R_1_SIZ
);
369 rimm
= (inst
>> FT32_FLD_RIMM_BIT
) & LSBS (FT32_FLD_RIMM_SIZ
);
370 r_2
= (inst
>> FT32_FLD_R_2_BIT
) & LSBS (FT32_FLD_R_2_SIZ
);
371 k20
= nsigned (20, (inst
>> FT32_FLD_K20_BIT
) & LSBS (FT32_FLD_K20_SIZ
));
372 pa
= (inst
>> FT32_FLD_PA_BIT
) & LSBS (FT32_FLD_PA_SIZ
);
373 aa
= (inst
>> FT32_FLD_AA_BIT
) & LSBS (FT32_FLD_AA_SIZ
);
374 k16
= (inst
>> FT32_FLD_K16_BIT
) & LSBS (FT32_FLD_K16_SIZ
);
375 k15
= (inst
>> FT32_FLD_K15_BIT
) & LSBS (FT32_FLD_K15_SIZ
);
380 al
= (inst
>> FT32_FLD_AL_BIT
) & LSBS (FT32_FLD_AL_SIZ
);
382 r_1v
= cpu
->state
.regs
[r_1
];
383 rimmv
= (rimm
& 0x400) ? nsigned (10, rimm
) : cpu
->state
.regs
[rimm
& 0x1f];
385 bit_pos
= rimmv
& 31;
386 bit_len
= 0xf & (rimmv
>> 5);
390 upper
= (inst
>> 27);
392 insnpc
= cpu
->state
.pc
;
399 int take
= (cr
== 3) || ((1 & (cpu
->state
.regs
[28 + cr
] >> cb
)) == cv
);
402 cpu
->state
.cycles
+= 1;
404 ft32_push (sd
, cpu
->state
.pc
); /* this is a call. */
405 if (upper
== FT32_PAT_TOC
)
406 cpu
->state
.pc
= pa
<< 2;
408 cpu
->state
.pc
= cpu
->state
.regs
[r_2
];
409 if (cpu
->state
.pc
== 0x8)
421 case 0x0: result
= r_1v
+ rimmv
; break;
422 case 0x1: result
= ror (r_1v
, rimmv
); break;
423 case 0x2: result
= r_1v
- rimmv
; break;
424 case 0x3: result
= (r_1v
<< 10) | (1023 & rimmv
); break;
425 case 0x4: result
= r_1v
& rimmv
; break;
426 case 0x5: result
= r_1v
| rimmv
; break;
427 case 0x6: result
= r_1v
^ rimmv
; break;
428 case 0x7: result
= ~(r_1v
^ rimmv
); break;
429 case 0x8: result
= r_1v
<< rimmv
; break;
430 case 0x9: result
= r_1v
>> rimmv
; break;
431 case 0xa: result
= (int32_t)r_1v
>> rimmv
; break;
432 case 0xb: result
= bins (r_1v
, rimmv
>> 10, bit_len
, bit_pos
); break;
433 case 0xc: result
= nsigned (bit_len
, r_1v
>> bit_pos
); break;
434 case 0xd: result
= nunsigned (bit_len
, r_1v
>> bit_pos
); break;
435 case 0xe: result
= flip (r_1v
, rimmv
); break;
437 sim_io_eprintf (sd
, "Unhandled alu %#x\n", al
);
440 if (upper
== FT32_PAT_ALUOP
)
441 cpu
->state
.regs
[r_d
] = result
;
461 case 0: dwsiz
= 7; dwmask
= 0xffU
; break;
462 case 1: dwsiz
= 15; dwmask
= 0xffffU
; break;
463 case 2: dwsiz
= 31; dwmask
= 0xffffffffU
; break;
466 zero
= (0 == (result
& dwmask
));
467 sign
= 1 & (result
>> dwsiz
);
468 ahi
= 1 & (r_1v
>> dwsiz
);
469 bhi
= 1 & (rimmv
>> dwsiz
);
470 overflow
= (sign
!= ahi
) & (ahi
== !bhi
);
476 case 0x0: carry
= 1 & ((ra
+ rb
) >> bit
); break;
477 case 0x2: carry
= 1 & ((ra
- rb
) >> bit
); break;
478 default: carry
= 0; break;
480 above
= (!carry
& !zero
);
481 greater
= (sign
== overflow
) & !zero
;
482 greatereq
= (sign
== overflow
);
484 cpu
->state
.regs
[r_d
] = (
497 cpu
->state
.regs
[r_d
] = k20
;
501 cpu
->state
.regs
[r_d
] = ft32_read_item (sd
, dw
, pa
<< 2);
502 cpu
->state
.cycles
+= 1;
506 cpu
->state
.regs
[r_d
] = ft32_read_item (sd
, dw
, cpu
->state
.regs
[r_1
] + k15
);
507 cpu
->state
.cycles
+= 1;
511 cpu_mem_write (sd
, dw
, aa
, cpu
->state
.regs
[r_d
]);
515 cpu_mem_write (sd
, dw
, cpu
->state
.regs
[r_d
] + k15
, cpu
->state
.regs
[r_1
]);
519 cpu
->state
.regs
[r_d
] = cpu_mem_read (sd
, dw
, aa
);
520 cpu
->state
.cycles
+= 1;
524 cpu
->state
.regs
[r_d
] = cpu_mem_read (sd
, dw
, cpu
->state
.regs
[r_1
] + k15
);
525 cpu
->state
.cycles
+= 1;
531 tmp
= cpu_mem_read (sd
, dw
, aa
);
532 cpu_mem_write (sd
, dw
, aa
, cpu
->state
.regs
[r_d
]);
533 cpu
->state
.regs
[r_d
] = tmp
;
534 cpu
->state
.cycles
+= 1;
541 tmp
= cpu_mem_read (sd
, dw
, cpu
->state
.regs
[r_1
] + k15
);
542 cpu_mem_write (sd
, dw
, cpu
->state
.regs
[r_1
] + k15
, cpu
->state
.regs
[r_d
]);
543 cpu
->state
.regs
[r_d
] = tmp
;
544 cpu
->state
.cycles
+= 1;
549 ft32_push (sd
, r_1v
);
553 ft32_push (sd
, cpu
->state
.regs
[r_d
]);
554 cpu
->state
.regs
[r_d
] = cpu
->state
.regs
[FT32_HARD_SP
];
555 cpu
->state
.regs
[FT32_HARD_SP
] -= k16
;
556 cpu
->state
.regs
[FT32_HARD_SP
] &= 0xffff;
559 case FT32_PAT_UNLINK
:
560 cpu
->state
.regs
[FT32_HARD_SP
] = cpu
->state
.regs
[r_d
];
561 cpu
->state
.regs
[FT32_HARD_SP
] &= 0xffff;
562 cpu
->state
.regs
[r_d
] = ft32_pop (sd
);
566 cpu
->state
.cycles
+= 1;
567 cpu
->state
.regs
[r_d
] = ft32_pop (sd
);
570 case FT32_PAT_RETURN
:
571 cpu
->state
.pc
= ft32_pop (sd
);
578 cpu
->state
.regs
[r_d
] = r_1v
/ rimmv
;
581 cpu
->state
.regs
[r_d
] = r_1v
% rimmv
;
584 cpu
->state
.regs
[r_d
] = ft32sdiv (r_1v
, rimmv
);
587 cpu
->state
.regs
[r_d
] = ft32smod (r_1v
, rimmv
);
592 /* strcmp instruction. */
596 while ((GET_BYTE (a
+ i
) != 0) &&
597 (GET_BYTE (a
+ i
) == GET_BYTE (b
+ i
)))
599 cpu
->state
.regs
[r_d
] = GET_BYTE (a
+ i
) - GET_BYTE (b
+ i
);
605 /* memcpy instruction. */
607 uint32_t dst
= cpu
->state
.regs
[r_d
];
609 for (i
= 0; i
< (rimmv
& 0x7fff); i
++)
610 PUT_BYTE (dst
+ i
, GET_BYTE (src
+ i
));
615 /* strlen instruction. */
618 for (i
= 0; GET_BYTE (src
+ i
) != 0; i
++)
620 cpu
->state
.regs
[r_d
] = i
;
625 /* memset instruction. */
626 uint32_t dst
= cpu
->state
.regs
[r_d
];
628 for (i
= 0; i
< (rimmv
& 0x7fff); i
++)
629 PUT_BYTE (dst
+ i
, r_1v
);
633 cpu
->state
.regs
[r_d
] = r_1v
* rimmv
;
636 cpu
->state
.regs
[r_d
] = ((uint64_t)r_1v
* (uint64_t)rimmv
) >> 32;
640 /* stpcpy instruction. */
642 uint32_t dst
= cpu
->state
.regs
[r_d
];
644 for (i
= 0; GET_BYTE (src
+ i
) != 0; i
++)
645 PUT_BYTE (dst
+ i
, GET_BYTE (src
+ i
));
646 PUT_BYTE (dst
+ i
, 0);
647 cpu
->state
.regs
[r_d
] = dst
+ i
;
652 /* streamout instruction. */
654 uint32_t src
= cpu
->state
.regs
[r_1
];
655 for (i
= 0; i
< rimmv
; i
+= (1 << dw
))
659 cpu
->state
.regs
[r_d
],
660 cpu_mem_read (sd
, dw
, src
));
666 sim_io_eprintf (sd
, "Unhandled ffu %#x at %08x\n", al
, insnpc
);
672 sim_io_eprintf (sd
, "Unhandled pattern %d at %08x\n", upper
, insnpc
);
682 sim_engine_run (SIM_DESC sd
,
683 int next_cpu_nr
, /* ignore */
684 int nr_cpus
, /* ignore */
685 int siggnal
) /* ignore */
689 SIM_ASSERT (STATE_MAGIC (sd
) == SIM_MAGIC_NUMBER
);
691 cpu
= STATE_CPU (sd
, 0);
696 if (sim_events_tick (sd
))
697 sim_events_process (sd
);
702 ft32_lookup_register (SIM_CPU
*cpu
, int nr
)
704 /* Handle the register number translation here.
705 * Sim registers are 0-31.
706 * Other tools (gcc, gdb) use:
713 if ((nr
< 0) || (nr
> 32))
715 sim_io_eprintf (CPU_STATE (cpu
), "unknown register %i\n", nr
);
722 return &cpu
->state
.regs
[FT32_HARD_FP
];
724 return &cpu
->state
.regs
[FT32_HARD_SP
];
726 return &cpu
->state
.regs
[FT32_HARD_CC
];
728 return &cpu
->state
.pc
;
730 return &cpu
->state
.regs
[nr
- 2];
735 ft32_reg_store (SIM_CPU
*cpu
,
737 unsigned char *memory
,
740 if (0 <= rn
&& rn
<= 32)
743 *ft32_lookup_register (cpu
, rn
) = ft32_extract_unsigned_integer (memory
, 4);
752 ft32_reg_fetch (SIM_CPU
*cpu
,
754 unsigned char *memory
,
757 if (0 <= rn
&& rn
<= 32)
760 ft32_store_unsigned_integer (memory
, 4, *ft32_lookup_register (cpu
, rn
));
769 ft32_pc_get (SIM_CPU
*cpu
)
771 return cpu
->state
.pc
;
775 ft32_pc_set (SIM_CPU
*cpu
, sim_cia newpc
)
777 cpu
->state
.pc
= newpc
;
780 /* Cover function of sim_state_free to free the cpu buffers as well. */
783 free_state (SIM_DESC sd
)
785 if (STATE_MODULES (sd
) != NULL
)
786 sim_module_uninstall (sd
);
787 sim_cpu_free_all (sd
);
792 sim_open (SIM_OPEN_KIND kind
,
799 SIM_DESC sd
= sim_state_alloc (kind
, cb
);
801 /* The cpu data is kept in a separately allocated chunk of memory. */
802 if (sim_cpu_alloc_all (sd
, 1, /*cgen_cpu_max_extra_bytes ()*/0) != SIM_RC_OK
)
808 if (sim_pre_argv_init (sd
, argv
[0]) != SIM_RC_OK
)
814 /* The parser will print an error message for us, so we silently return. */
815 if (sim_parse_args (sd
, argv
) != SIM_RC_OK
)
821 /* Allocate external memory if none specified by user.
822 Use address 4 here in case the user wanted address 0 unmapped. */
823 if (sim_core_read_buffer (sd
, NULL
, read_map
, &c
, 4, 1) == 0)
825 sim_do_command (sd
, "memory region 0x00000000,0x40000");
826 sim_do_command (sd
, "memory region 0x800000,0x10000");
829 /* Check for/establish the reference program image. */
830 if (sim_analyze_program (sd
,
831 (STATE_PROG_ARGV (sd
) != NULL
832 ? *STATE_PROG_ARGV (sd
)
833 : NULL
), abfd
) != SIM_RC_OK
)
839 /* Configure/verify the target byte order and other runtime
840 configuration options. */
841 if (sim_config (sd
) != SIM_RC_OK
)
847 if (sim_post_argv_init (sd
) != SIM_RC_OK
)
853 /* CPU specific initialization. */
854 for (i
= 0; i
< MAX_NR_PROCESSORS
; ++i
)
856 SIM_CPU
*cpu
= STATE_CPU (sd
, i
);
858 CPU_REG_FETCH (cpu
) = ft32_reg_fetch
;
859 CPU_REG_STORE (cpu
) = ft32_reg_store
;
860 CPU_PC_FETCH (cpu
) = ft32_pc_get
;
861 CPU_PC_STORE (cpu
) = ft32_pc_set
;
868 sim_create_inferior (SIM_DESC sd
,
874 sim_cpu
*cpu
= STATE_CPU (sd
, 0);
878 addr
= bfd_get_start_address (abfd
);
882 /* Standalone mode (i.e. `run`) will take care of the argv for us in
883 sim_open() -> sim_parse_args(). But in debug mode (i.e. 'target sim'
884 with `gdb`), we need to handle it because the user can change the
885 argv on the fly via gdb's 'run'. */
886 if (STATE_PROG_ARGV (sd
) != argv
)
888 freeargv (STATE_PROG_ARGV (sd
));
889 STATE_PROG_ARGV (sd
) = dupargv (argv
);
891 cpu
->state
.regs
[FT32_HARD_SP
] = addr
;
892 cpu
->state
.num_i
= 0;
893 cpu
->state
.cycles
= 0;
894 cpu
->state
.next_tick_cycle
= 100000;
This page took 0.070618 seconds and 4 git commands to generate.