+2021-04-08 Tom Tromey <tom@tromey.com>
+
+ * bpf.c (bpf_def_model_init): Use new-style declaration.
+
2021-04-02 Mike Frysinger <vapier@gentoo.org>
* aclocal.m4, configure: Regenerate.
several ISAs. This should be fixed in CGEN. */
static void
-bpf_def_model_init ()
+bpf_def_model_init (void)
{
/* Do nothing. */
}
+2021-04-08 Tom Tromey <tom@tromey.com>
+
+ * cgen-utils.c (RORQI, ROLQI, RORHI, ROLHI, RORSI, ROLSI): Use
+ new-style declaration.
+
2021-04-03 Mike Frysinger <vapier@gentoo.org>
* Make-common.in (install-common): Install as run-$arch and
#endif /* DI_FN_SUPPORT */
\f
QI
-RORQI (val, shift)
- QI val;
- int shift;
+RORQI (QI val, int shift)
{
if (shift != 0)
{
}
QI
-ROLQI (val, shift)
- QI val;
- int shift;
+ROLQI (QI val, int shift)
{
if (shift != 0)
{
}
HI
-RORHI (val, shift)
- HI val;
- int shift;
+RORHI (HI val, int shift)
{
if (shift != 0)
{
}
HI
-ROLHI (val, shift)
- HI val;
- int shift;
+ROLHI (HI val, int shift)
{
if (shift != 0)
{
}
SI
-RORSI (val, shift)
- SI val;
- int shift;
+RORSI (SI val, int shift)
{
if (shift != 0)
{
}
SI
-ROLSI (val, shift)
- SI val;
- int shift;
+ROLSI (SI val, int shift)
{
if (shift != 0)
{
+2021-04-08 Tom Tromey <tom@tromey.com>
+
+ * sis.c (run_sim, main): Use new-style declaration.
+ * interf.c (run_sim, sim_open, sim_close, sim_load)
+ (sim_create_inferior, sim_store_register, sim_fetch_register)
+ (sim_info, sim_stop_reason, flush_windows, sim_do_command): Use
+ new-style declaration.
+ * help.c (usage, gen_help): Use new-style declaration.
+ * func.c (batch, set_regi, set_rega, disp_reg, limcalc)
+ (reset_stat, show_stat, init_bpt, int_handler, init_signals)
+ (disp_fpu, disp_regs, disp_ctrl, disp_mem, dis_mem, event)
+ (init_event, set_int, advance_time, now, wait_for_irq, check_bpt)
+ (reset_all, sys_reset, sys_halt): Use new-style declaration.
+ * float.c (get_accex, clear_accex, set_fsr): Use new-style
+ declaration.
+ * exec.c (sub_cc, add_cc, log_cc, dispatch_instruction, fpexec)
+ (chk_asi, execute_trap, check_interrupts, init_regs): Use
+ new-style declaration.
+ * erc32.c (init_sim, reset, decode_ersr, mecparerror)
+ (error_mode, decode_memcfg, decode_wcr, decode_mcr, sim_halt)
+ (close_port, exit_sim, mec_reset, mec_intack, chk_irq, mec_irq)
+ (set_sfsr, mec_read, mec_write, init_stdio, restore_stdio)
+ (port_init, read_uart, write_uart, flush_uart, uarta_tx)
+ (uartb_tx, uart_rx, uart_intr, uart_irq_start, wdog_intr)
+ (wdog_start, rtc_intr, rtc_start, rtc_counter_read)
+ (rtc_scaler_set, rtc_reload_set, gpt_intr, gpt_start)
+ (gpt_counter_read, gpt_scaler_set, gpt_reload_set, timer_ctrl)
+ (memory_read, memory_write, get_mem_ptr, sis_memory_write)
+ (sis_memory_read): Use new-style declaration.
+
2021-04-05 Tom Tromey <tromey@adacore.com>
* configure: Rebuild.
/* One-time init */
void
-init_sim()
+init_sim(void)
{
port_init();
}
/* Power-on reset init */
void
-reset()
+reset(void)
{
mec_reset();
uart_irq_start();
}
static void
-decode_ersr()
+decode_ersr(void)
{
if (mec_ersr & 0x01) {
if (!(mec_mcr & 0x20)) {
#endif
static void
-mecparerror()
+mecparerror(void)
{
mec_ersr |= 0x20;
decode_ersr();
/* IU error mode manager */
void
-error_mode(pc)
- uint32 pc;
+error_mode(uint32 pc)
{
mec_ersr |= 0x1;
/* Check memory settings */
static void
-decode_memcfg()
+decode_memcfg(void)
{
if (rom8) mec_memcfg &= ~0x20000;
else mec_memcfg |= 0x20000;
}
static void
-decode_wcr()
+decode_wcr(void)
{
mem_ramr_ws = mec_wcr & 3;
mem_ramw_ws = (mec_wcr >> 2) & 3;
}
static void
-decode_mcr()
+decode_mcr(void)
{
mem_accprot = (mec_wpr[0] | mec_wpr[1]);
mem_blockprot = (mec_mcr >> 3) & 1;
/* Flush ports when simulator stops */
void
-sim_halt()
+sim_halt(void)
{
#ifdef FAST_UART
flush_uart();
}
static void
-close_port()
+close_port(void)
{
if (f1open && f1in != stdin)
fclose(f1in);
}
void
-exit_sim()
+exit_sim(void)
{
close_port();
}
static void
-mec_reset()
+mec_reset(void)
{
int i;
static void
-mec_intack(level)
- int32 level;
+mec_intack(int32 level)
{
int irq_test;
}
static void
-chk_irq()
+chk_irq(void)
{
int32 i;
uint32 itmp;
}
static void
-mec_irq(level)
- int32 level;
+mec_irq(int32 level)
{
mec_ipr |= (1 << level);
chk_irq();
}
static void
-set_sfsr(fault, addr, asi, read)
- uint32 fault;
- uint32 addr;
- uint32 asi;
- uint32 read;
+set_sfsr(uint32 fault, uint32 addr, uint32 asi, uint32 read)
{
if ((asi == 0xa) || (asi == 0xb)) {
mec_ffar = addr;
}
static int32
-mec_read(addr, asi, data)
- uint32 addr;
- uint32 asi;
- uint32 *data;
+mec_read(uint32 addr, uint32 asi, uint32 *data)
{
switch (addr & 0x0ff) {
}
static int
-mec_write(addr, data)
- uint32 addr;
- uint32 data;
+mec_write(uint32 addr, uint32 data)
{
if (sis_verbose > 1)
printf("MEC write a: %08x, d: %08x\n",addr,data);
static int ifd1 = -1, ifd2 = -1, ofd1 = -1, ofd2 = -1;
void
-init_stdio()
+init_stdio(void)
{
if (dumbio)
return; /* do nothing */
}
void
-restore_stdio()
+restore_stdio(void)
{
if (dumbio)
return; /* do nothing */
static void
-port_init()
+port_init(void)
{
if (uben) {
}
static uint32
-read_uart(addr)
- uint32 addr;
+read_uart(uint32 addr)
{
unsigned tmp;
}
static void
-write_uart(addr, data)
- uint32 addr;
- uint32 data;
+write_uart(uint32 addr, uint32 data)
{
unsigned char c;
}
static void
-flush_uart()
+flush_uart(void)
{
while (wnuma && f1open)
wnuma -= fwrite(wbufa, 1, wnuma, f1out);
static void
-uarta_tx()
+uarta_tx(void)
{
while (f1open && fwrite(&uarta_sreg, 1, 1, f1out) != 1);
}
static void
-uartb_tx()
+uartb_tx(void)
{
while (f2open && fwrite(&uartb_sreg, 1, 1, f2out) != 1);
if (uart_stat_reg & UARTB_HRE) {
}
static void
-uart_rx(arg)
- caddr_t arg;
+uart_rx(caddr_t arg)
{
int32 rsize;
char rxd;
}
static void
-uart_intr(arg)
- caddr_t arg;
+uart_intr(caddr_t arg)
{
read_uart(0xE8); /* Check for UART interrupts every 1000 clk */
flush_uart(); /* Flush UART ports */
static void
-uart_irq_start()
+uart_irq_start(void)
{
#ifdef FAST_UART
event(uart_intr, 0, UART_FLUSH_TIME);
/* Watch-dog */
static void
-wdog_intr(arg)
- caddr_t arg;
+wdog_intr(caddr_t arg)
{
if (wdog_status == disabled) {
wdog_status = stopped;
}
static void
-wdog_start()
+wdog_start(void)
{
event(wdog_intr, 0, wdog_scaler + 1);
if (sis_verbose)
static void
-rtc_intr(arg)
- caddr_t arg;
+rtc_intr(caddr_t arg)
{
if (rtc_counter == 0) {
}
static void
-rtc_start()
+rtc_start(void)
{
if (sis_verbose)
printf("RTC started (period %d)\n\r", rtc_scaler + 1);
}
static uint32
-rtc_counter_read()
+rtc_counter_read(void)
{
return rtc_counter;
}
static void
-rtc_scaler_set(val)
- uint32 val;
+rtc_scaler_set(uint32 val)
{
rtc_scaler = val & 0x0ff; /* eight-bit scaler only */
}
static void
-rtc_reload_set(val)
- uint32 val;
+rtc_reload_set(uint32 val)
{
rtc_reload = val;
}
static void
-gpt_intr(arg)
- caddr_t arg;
+gpt_intr(caddr_t arg)
{
if (gpt_counter == 0) {
mec_irq(12);
}
static void
-gpt_start()
+gpt_start(void)
{
if (sis_verbose)
printf("GPT started (period %d)\n\r", gpt_scaler + 1);
}
static uint32
-gpt_counter_read()
+gpt_counter_read(void)
{
return gpt_counter;
}
static void
-gpt_scaler_set(val)
- uint32 val;
+gpt_scaler_set(uint32 val)
{
gpt_scaler = val & 0x0ffff; /* 16-bit scaler */
}
static void
-gpt_reload_set(val)
- uint32 val;
+gpt_reload_set(uint32 val)
{
gpt_reload = val;
}
static void
-timer_ctrl(val)
- uint32 val;
+timer_ctrl(uint32 val)
{
rtc_cr = ((val & TCR_TCRCR) != 0);
}
int
-memory_read(asi, addr, data, sz, ws)
- int32 asi;
- uint32 addr;
- uint32 *data;
- int32 sz;
- int32 *ws;
+memory_read(int32 asi, uint32 addr, uint32 *data, int32 sz, int32 *ws)
{
int32 mexc;
}
int
-memory_write(asi, addr, data, sz, ws)
- int32 asi;
- uint32 addr;
- uint32 *data;
- int32 sz;
- int32 *ws;
+memory_write(int32 asi, uint32 addr, uint32 *data, int32 sz, int32 *ws)
{
uint32 byte_addr;
uint32 byte_mask;
}
static unsigned char *
-get_mem_ptr(addr, size)
- uint32 addr;
- uint32 size;
+get_mem_ptr(uint32 addr, uint32 size)
{
if ((addr + size) < ROM_SZ) {
return &romb[addr];
}
int
-sis_memory_write(addr, data, length)
- uint32 addr;
- const unsigned char *data;
- uint32 length;
+sis_memory_write(uint32 addr, const unsigned char *data, uint32 length)
{
char *mem;
}
int
-sis_memory_read(addr, data, length)
- uint32 addr;
- char *data;
- uint32 length;
+sis_memory_read(uint32 addr, char *data, uint32 length)
{
char *mem;
#endif
static uint32
-sub_cc(psr, operand1, operand2, result)
- uint32 psr;
- int32 operand1;
- int32 operand2;
- int32 result;
+sub_cc(uint32 psr, int32 operand1, int32 operand2, int32 result)
{
psr = ((psr & ~PSR_N) | ((result >> 8) & PSR_N));
if (result)
}
uint32
-add_cc(psr, operand1, operand2, result)
- uint32 psr;
- int32 operand1;
- int32 operand2;
- int32 result;
+add_cc(uint32 psr, int32 operand1, int32 operand2, int32 result)
{
psr = ((psr & ~PSR_N) | ((result >> 8) & PSR_N));
if (result)
}
static void
-log_cc(result, sregs)
- int32 result;
- struct pstate *sregs;
+log_cc(int32 result, struct pstate *sregs)
{
sregs->psr &= ~(PSR_CC); /* Zero CC bits */
sregs->psr = (sregs->psr | ((result >> 8) & PSR_N));
}
int
-dispatch_instruction(sregs)
- struct pstate *sregs;
+dispatch_instruction(struct pstate *sregs)
{
uint32 cwp, op, op2, op3, asi, rd, cond, rs1,
static int
-fpexec(op3, rd, rs1, rs2, sregs)
- uint32 op3, rd, rs1, rs2;
- struct pstate *sregs;
+fpexec(uint32 op3, uint32 rd, uint32 rs1, uint32 rs2, struct pstate *sregs)
{
uint32 opf, tem, accex;
int32 fcc;
}
static int
-chk_asi(sregs, asi, op3)
- struct pstate *sregs;
- uint32 *asi, op3;
-
+chk_asi(struct pstate *sregs, uint32 *asi, uint32 op3)
{
if (!(sregs->psr & PSR_S)) {
sregs->trap = TRAP_PRIVI;
}
int
-execute_trap(sregs)
- struct pstate *sregs;
+execute_trap(struct pstate *sregs)
{
int32 cwp;
extern struct irqcell irqarr[16];
int
-check_interrupts(sregs)
- struct pstate *sregs;
+check_interrupts(struct pstate *sregs)
{
#ifdef ERRINJ
if (errtt) {
}
void
-init_regs(sregs)
- struct pstate *sregs;
+init_regs(struct pstate *sregs)
{
sregs->pc = 0;
sregs->npc = 4;
/* This routine should return the accrued exceptions */
int
-get_accex()
+get_accex(void)
{
int fexc, accx;
/* How to clear the accrued exceptions */
void
-clear_accex()
+clear_accex(void)
{
feclearexcept (FE_ALL_EXCEPT);
}
/* How to map SPARC FSR onto the host */
void
-set_fsr(fsr)
-uint32 fsr;
+set_fsr(uint32 fsr)
{
int fround;
static void disp_mem (uint32 addr, uint32 len);
static int
-batch(sregs, fname)
- struct pstate *sregs;
- char *fname;
+batch(struct pstate *sregs, char *fname)
{
FILE *fp;
char *lbuf = NULL;
}
void
-set_regi(sregs, reg, rval)
- struct pstate *sregs;
- int32 reg;
- uint32 rval;
+set_regi(struct pstate *sregs, int32 reg, uint32 rval)
{
uint32 cwp;
static void
-set_rega(sregs, reg, rval)
- struct pstate *sregs;
- char *reg;
- uint32 rval;
+set_rega(struct pstate *sregs, char *reg, uint32 rval)
{
uint32 cwp;
int32 err = 0;
}
static void
-disp_reg(sregs, reg)
- struct pstate *sregs;
- char *reg;
+disp_reg(struct pstate *sregs, char *reg)
{
if (strncmp(reg, "w",1) == 0)
disp_regs(sregs, VAL(®[1]));
#endif
static uint32
-limcalc (freq)
- float32 freq;
+limcalc (float32 freq)
{
uint32 unit, lim;
double flim;
void
-reset_stat(sregs)
- struct pstate *sregs;
+reset_stat(struct pstate *sregs)
{
sregs->tottime = 0.0;
sregs->pwdtime = 0;
}
void
-show_stat(sregs)
- struct pstate *sregs;
+show_stat(struct pstate *sregs)
{
uint32 iinst;
uint32 stime;
void
-init_bpt(sregs)
- struct pstate *sregs;
+init_bpt(struct pstate *sregs)
{
sregs->bptnum = 0;
sregs->histlen = 0;
}
static void
-int_handler(sig)
- int32 sig;
+int_handler(int32 sig)
{
if (sig != 2)
printf("\n\n Signal handler error (%d)\n\n", sig);
}
void
-init_signals()
+init_signals(void)
{
typedef void (*PFI) ();
static PFI int_tab[2];
struct irqcell irqarr[16];
static int
-disp_fpu(sregs)
- struct pstate *sregs;
+disp_fpu(struct pstate *sregs)
{
int i;
}
static void
-disp_regs(sregs,cwp)
- struct pstate *sregs;
- int cwp;
+disp_regs(struct pstate *sregs, int cwp)
{
int i;
}
static void
-disp_ctrl(sregs)
- struct pstate *sregs;
+disp_ctrl(struct pstate *sregs)
{
uint32 i;
}
static void
-disp_mem(addr, len)
- uint32 addr;
- uint32 len;
+disp_mem(uint32 addr, uint32 len)
{
uint32 i;
}
void
-dis_mem(addr, len, info)
- uint32 addr;
- uint32 len;
- struct disassemble_info *info;
+dis_mem(uint32 addr, uint32 len, struct disassemble_info *info)
{
uint32 i;
union {
/* Add event to event queue */
void
-event(cfunc, arg, delta)
- void (*cfunc) ();
- int32 arg;
- uint64 delta;
+event(void (*cfunc) (), int32 arg, uint64 delta)
{
struct evcell *ev1, *evins;
#endif
void
-init_event()
+init_event(void)
{
int32 i;
}
void
-set_int(level, callback, arg)
- int32 level;
- void (*callback) ();
- int32 arg;
+set_int(int32 level, void (*callback) (), int32 arg)
{
irqarr[level & 0x0f].callback = callback;
irqarr[level & 0x0f].arg = arg;
/* Advance simulator time */
void
-advance_time(sregs)
- struct pstate *sregs;
+advance_time(struct pstate *sregs)
{
struct evcell *evrem;
}
uint32
-now()
+now(void)
{
return ebase.simtime;
}
/* Advance time until an external interrupt is seen */
int
-wait_for_irq()
+wait_for_irq(void)
{
struct evcell *evrem;
void (*cfunc) ();
}
int
-check_bpt(sregs)
- struct pstate *sregs;
+check_bpt(struct pstate *sregs)
{
int32 i;
}
void
-reset_all()
+reset_all(void)
{
init_event(); /* Clear event queue */
init_regs(&sregs);
}
void
-sys_reset()
+sys_reset(void)
{
reset_all();
sregs.trap = 256; /* Force fake reset trap */
}
void
-sys_halt()
+sys_halt(void)
{
sregs.trap = 257; /* Force fake halt trap */
}
#include "sis.h"
void
-usage()
+usage(void)
{
printf("usage: sis [-uart1 uart_device1] [-uart2 uart_device2]\n");
}
void
-gen_help()
+gen_help(void)
{
printf("\n batch <file> execute a batch file of SIS commands\n");
host_callback *sim_callback;
int
-run_sim(sregs, icount, dis)
- struct pstate *sregs;
- uint64 icount;
- int dis;
+run_sim(struct pstate *sregs, uint64 icount, int dis)
{
int mexc, irq;
}
SIM_DESC
-sim_open (kind, callback, abfd, argv)
- SIM_OPEN_KIND kind;
- struct host_callback_struct *callback;
- struct bfd *abfd;
- char * const *argv;
+sim_open (SIM_OPEN_KIND kind, struct host_callback_struct *callback,
+ struct bfd *abfd, char * const *argv)
{
int argc = 0;
}
void
-sim_close(sd, quitting)
- SIM_DESC sd;
- int quitting;
+sim_close(SIM_DESC sd, int quitting)
{
exit_sim();
};
SIM_RC
-sim_load(sd, prog, abfd, from_tty)
- SIM_DESC sd;
- const char *prog;
- bfd *abfd;
- int from_tty;
+sim_load(SIM_DESC sd, const char *prog, bfd *abfd, int from_tty)
{
bfd_load (prog);
return SIM_RC_OK;
}
SIM_RC
-sim_create_inferior(sd, abfd, argv, env)
- SIM_DESC sd;
- struct bfd *abfd;
- char * const *argv;
- char * const *env;
+sim_create_inferior(SIM_DESC sd, bfd *abfd, char * const *argv,
+ char * const *env)
{
bfd_vma start_address = 0;
if (abfd != NULL)
}
int
-sim_store_register(sd, regno, value, length)
- SIM_DESC sd;
- int regno;
- unsigned char *value;
- int length;
+sim_store_register(SIM_DESC sd, int regno, unsigned char *value, int length)
{
int regval;
int
-sim_fetch_register(sd, regno, buf, length)
- SIM_DESC sd;
- int regno;
- unsigned char *buf;
- int length;
+sim_fetch_register(SIM_DESC sd, int regno, unsigned char *buf, int length)
{
get_regi(&sregs, regno, buf);
return -1;
}
void
-sim_info(sd, verbose)
- SIM_DESC sd;
- int verbose;
+sim_info(SIM_DESC sd, int verbose)
{
show_stat(&sregs);
}
int simstat = OK;
void
-sim_stop_reason(sd, reason, sigrc)
- SIM_DESC sd;
- enum sim_stop * reason;
- int *sigrc;
+sim_stop_reason(SIM_DESC sd, enum sim_stop *reason, int *sigrc)
{
switch (simstat) {
*/
static void
-flush_windows ()
+flush_windows (void)
{
int invwin;
int cwp;
}
void
-sim_do_command(sd, cmd)
- SIM_DESC sd;
- const char *cmd;
+sim_do_command(SIM_DESC sd, const char *cmd)
{
exec_cmd(&sregs, cmd);
}
#endif
int
-run_sim(sregs, icount, dis)
- struct pstate *sregs;
- uint64 icount;
- int dis;
+run_sim(struct pstate *sregs, uint64 icount, int dis)
{
int irq, mexc, deb;
}
int
-main(argc, argv)
- int argc;
- char **argv;
+main(int argc, char **argv)
{
int cont = 1;
+2021-04-08 Tom Tromey <tom@tromey.com>
+
+ * sim-if.c (sim_open, frv_sim_close, sim_create_inferior): Use
+ new-style declaration.
+
2021-04-02 Mike Frysinger <vapier@gentoo.org>
* aclocal.m4, configure: Regenerate.
/* Create an instance of the simulator. */
SIM_DESC
-sim_open (kind, callback, abfd, argv)
- SIM_OPEN_KIND kind;
- host_callback *callback;
- bfd *abfd;
- char * const *argv;
+sim_open (SIM_OPEN_KIND kind, host_callback *callback, bfd *abfd,
+ char * const *argv)
{
char c;
int i;
}
void
-frv_sim_close (sd, quitting)
- SIM_DESC sd;
- int quitting;
+frv_sim_close (SIM_DESC sd, int quitting)
{
int i;
/* Terminate cache support. */
}
\f
SIM_RC
-sim_create_inferior (sd, abfd, argv, envp)
- SIM_DESC sd;
- bfd *abfd;
- char * const *argv;
- char * const *envp;
+sim_create_inferior (SIM_DESC sd, bfd *abfd, char * const *argv,
+ char * const *envp)
{
SIM_CPU *current_cpu = STATE_CPU (sd, 0);
SIM_ADDR addr;
+2021-04-08 Tom Tromey <tom@tromey.com>
+
+ * compile.c (cmdline_location): Use new-style declaration.
+
2021-04-02 Mike Frysinger <vapier@gentoo.org>
* aclocal.m4, configure: Regenerate.
}
static int
-cmdline_location()
+cmdline_location(void)
{
if (h8300smode && !h8300_normal_mode)
return 0xffff00L;
+2021-04-08 Tom Tromey <tom@tromey.com>
+
+ * sim-if.c (sim_open, sim_create_inferior): Use new-style
+ declaration.
+ * iq2000.c (fetch_str): Use new-style declaration.
+
2021-04-02 Mike Frysinger <vapier@gentoo.org>
* aclocal.m4, configure: Regenerate.
/* Read a null terminated string from memory, return in a buffer */
static char *
-fetch_str (current_cpu, pc, addr)
- SIM_CPU *current_cpu;
- PCADDR pc;
- DI addr;
+fetch_str (SIM_CPU *current_cpu, PCADDR pc, DI addr)
{
char *buf;
int nr = 0;
/* Create an instance of the simulator. */
SIM_DESC
-sim_open (kind, callback, abfd, argv)
- SIM_OPEN_KIND kind;
- host_callback *callback;
- struct bfd *abfd;
- char * const *argv;
+sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
+ char * const *argv)
{
char c;
int i;
}
\f
SIM_RC
-sim_create_inferior (sd, abfd, argv, envp)
- SIM_DESC sd;
- struct bfd *abfd;
- char * const *argv;
- char * const *envp;
+sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char * const *argv,
+ char * const *envp)
{
SIM_CPU *current_cpu = STATE_CPU (sd, 0);
SIM_ADDR addr;
+2021-04-08 Tom Tromey <tom@tromey.com>
+
+ * sim-if.c (sim_open, sim_create_inferior): Use new-style
+ declaration.
+
2021-04-02 Mike Frysinger <vapier@gentoo.org>
* aclocal.m4, configure: Regenerate.
/* Create an instance of the simulator. */
SIM_DESC
-sim_open (kind, callback, abfd, argv)
- SIM_OPEN_KIND kind;
- host_callback *callback;
- struct bfd *abfd;
- char * const *argv;
+sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
+ char * const *argv)
{
SIM_DESC sd = sim_state_alloc (kind, callback);
char c;
}
\f
SIM_RC
-sim_create_inferior (sd, abfd, argv, envp)
- SIM_DESC sd;
- struct bfd *abfd;
- char * const *argv;
- char * const *envp;
+sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char * const *argv,
+ char * const *envp)
{
SIM_CPU *current_cpu = STATE_CPU (sd, 0);
SIM_ADDR addr;
+2021-04-08 Tom Tromey <tom@tromey.com>
+
+ * sim-if.c (sim_open, sim_create_inferior): Use new-style
+ declaration.
+
2021-04-02 Mike Frysinger <vapier@gentoo.org>
* aclocal.m4, configure: Regenerate.
/* Create an instance of the simulator. */
SIM_DESC
-sim_open (kind, callback, abfd, argv)
- SIM_OPEN_KIND kind;
- host_callback *callback;
- struct bfd *abfd;
- char * const *argv;
+sim_open (SIM_OPEN_KIND kind, host_callback *callback, struct bfd *abfd,
+ char * const *argv)
{
SIM_DESC sd = sim_state_alloc (kind, callback);
char c;
}
\f
SIM_RC
-sim_create_inferior (sd, abfd, argv, envp)
- SIM_DESC sd;
- struct bfd *abfd;
- char * const *argv;
- char * const *envp;
+sim_create_inferior (SIM_DESC sd, struct bfd *abfd, char * const *argv,
+ char * const *envp)
{
SIM_CPU *current_cpu = STATE_CPU (sd, 0);
SIM_ADDR addr;
projects / binutils-gdb.git / commitdiff