source: rtems-tools/tools/4.12/gdb/gdb-7.11-erc32-printf_filtered.diff @ 0bbd2de

4.10
Last change on this file since 0bbd2de was 0bbd2de, checked in by Chris Johns <chrisj@…>, on Mar 16, 2016 at 4:18:34 AM

4.12: Patches for ERC simualtor for gdb-7.11.

The patches fix the endian checks in the simulator, print filtering,
and the run command.

Updates #2644.

  • Property mode set to 100644
File size: 36.6 KB
  • sim/erc32/erc32.c

    diff -ruw gdb-7.11.orig1/sim/erc32/erc32.c gdb-7.11/sim/erc32/erc32.c
    old new  
    1919/* The control space devices */
    2020
    2121#include "config.h"
     22#include <errno.h>
    2223#include <sys/types.h>
    2324#include <stdio.h>
    2425#include <string.h>
     
    3637extern char     uart_dev1[], uart_dev2[];
    3738
    3839int dumbio = 0; /* normal, smart, terminal oriented IO by default */
     40int tty_setup = 1; /* default setup if not a tty */
    3941
    4042/* MEC registers */
    4143#define MEC_START       0x01f80000
     
    293295
    294296extern int      ext_irl;
    295297
     298static host_callback *callback;
     299
    296300
    297301/* One-time init */
    298302
    299303void
    300304init_sim()
    301305{
     306    callback = sim_callback;
    302307    port_init();
    303308}
    304309
     
    321326                sys_reset();
    322327                mec_ersr = 0x8000;
    323328                if (sis_verbose)
    324                     printf("Error manager reset - IU in error mode\n");
     329                    (*sim_callback->printf_filtered) (sim_callback, "Error manager reset - IU in error mode\n");
    325330            } else {
    326331                sys_halt();
    327332                mec_ersr |= 0x2000;
    328333                if (sis_verbose)
    329                     printf("Error manager halt - IU in error mode\n");
     334                    (*sim_callback->printf_filtered) (sim_callback, "Error manager halt - IU in error mode\n");
    330335            }
    331336        } else
    332337            mec_irq(1);
     
    337342                sys_reset();
    338343                mec_ersr = 0x8000;
    339344                if (sis_verbose)
    340                     printf("Error manager reset - IU comparison error\n");
     345                    (*sim_callback->printf_filtered) (sim_callback, "Error manager reset - IU comparison error\n");
    341346            } else {
    342347                sys_halt();
    343348                mec_ersr |= 0x2000;
    344349                if (sis_verbose)
    345                     printf("Error manager halt - IU comparison error\n");
     350                    (*sim_callback->printf_filtered) (sim_callback, "Error manager halt - IU comparison error\n");
    346351            }
    347352        } else
    348353            mec_irq(1);
     
    353358                sys_reset();
    354359                mec_ersr = 0x8000;
    355360                if (sis_verbose)
    356                     printf("Error manager reset - MEC hardware error\n");
     361                    (*sim_callback->printf_filtered) (sim_callback, "Error manager reset - MEC hardware error\n");
    357362            } else {
    358363                sys_halt();
    359364                mec_ersr |= 0x2000;
    360365                if (sis_verbose)
    361                     printf("Error manager halt - MEC hardware error\n");
     366                    (*sim_callback->printf_filtered) (sim_callback, "Error manager halt - MEC hardware error\n");
    362367            }
    363368        } else
    364369            mec_irq(1);
     
    416421        mem_rammask = RAM_MASK;
    417422    }
    418423    if (sis_verbose)
    419         printf("RAM start: 0x%x, RAM size: %d K, ROM size: %d K\n",
     424        (*sim_callback->printf_filtered) (sim_callback, "RAM start: 0x%x, RAM size: %d K, ROM size: %d K\n",
    420425               mem_ramstart, mem_ramsz >> 10, mem_romsz >> 10);
    421426}
    422427
     
    432437    }
    433438    mem_romw_ws = (mec_wcr >> 8) & 0x0f;
    434439    if (sis_verbose)
    435         printf("Waitstates = RAM read: %d, RAM write: %d, ROM read: %d, ROM write: %d\n",
     440        (*sim_callback->printf_filtered) (sim_callback, "Waitstates = RAM read: %d, RAM write: %d, ROM read: %d, ROM write: %d\n",
    436441               mem_ramr_ws, mem_ramw_ws, mem_romr_ws, mem_romw_ws);
    437442}
    438443
     
    442447    mem_accprot = (mec_wpr[0] | mec_wpr[1]);
    443448    mem_blockprot = (mec_mcr >> 3) & 1;
    444449    if (sis_verbose && mem_accprot)
    445         printf("Memory block write protection enabled\n");
     450        (*sim_callback->printf_filtered) (sim_callback, "Memory block write protection enabled\n");
    446451    if (mec_mcr & 0x08000) {
    447452        mec_ersr |= 0x20;
    448453        decode_ersr();
    449454    }
    450455    if (sis_verbose && (mec_mcr & 2))
    451         printf("Software reset enabled\n");
     456        (*sim_callback->printf_filtered) (sim_callback, "Software reset enabled\n");
    452457    if (sis_verbose && (mec_mcr & 1))
    453         printf("Power-down mode enabled\n");
     458        (*sim_callback->printf_filtered) (sim_callback, "Power-down mode enabled\n");
    454459}
    455460
    456461/* Flush ports when simulator stops */
     
    553558    int             irq_test;
    554559
    555560    if (sis_verbose)
    556         printf("interrupt %d acknowledged\n", level);
     561        (*sim_callback->printf_filtered) (sim_callback, "interrupt %d acknowledged\n", level);
    557562    irq_test = mec_tcr & 0x80000;
    558563    if ((irq_test) && (mec_ifr & (1 << level)))
    559564        mec_ifr &= ~(1 << level);
     
    578583        for (i = 15; i > 0; i--) {
    579584            if (((itmp >> i) & 1) != 0) {
    580585                if ((sis_verbose) && (i > old_irl))
    581                     printf("IU irl: %d\n", i);
     586                    (*sim_callback->printf_filtered) (sim_callback, "IU irl: %d\n", i);
    582587                ext_irl = i;
    583588                set_int(i, mec_intack, i);
    584589                break;
     
    753758    uint32          data;
    754759{
    755760    if (sis_verbose > 1)
    756         printf("MEC write a: %08x, d: %08x\n",addr,data);
     761        (*sim_callback->printf_filtered) (sim_callback, "MEC write a: %08x, d: %08x\n",addr,data);
    757762    switch (addr & 0x0ff) {
    758763
    759764    case MEC_MCR:
     
    767772            sys_reset();
    768773            mec_ersr = 0x4000;
    769774            if (sis_verbose)
    770                 printf(" Software reset issued\n");
     775                (*sim_callback->printf_filtered) (sim_callback, " Software reset issued\n");
    771776        }
    772777        break;
    773778
     
    782787        mec_wpr[0] = (data >> 23) & 0x03;
    783788        mem_accprot = mec_wpr[0] || mec_wpr[1];
    784789        if (sis_verbose && mec_wpr[0])
    785             printf("Segment 1 memory protection enabled (0x02%06x - 0x02%06x)\n",
     790            (*sim_callback->printf_filtered) (sim_callback, "Segment 1 memory protection enabled (0x02%06x - 0x02%06x)\n",
    786791                   mec_ssa[0] << 2, mec_sea[0] << 2);
    787792        break;
    788793    case MEC_SEA1:              /* 0x24 */
     
    795800        mec_wpr[1] = (data >> 23) & 0x03;
    796801        mem_accprot = mec_wpr[0] || mec_wpr[1];
    797802        if (sis_verbose && mec_wpr[1])
    798             printf("Segment 2 memory protection enabled (0x02%06x - 0x02%06x)\n",
     803            (*sim_callback->printf_filtered) (sim_callback, "Segment 2 memory protection enabled (0x02%06x - 0x02%06x)\n",
    799804                   mec_ssa[1] << 2, mec_sea[1] << 2);
    800805        break;
    801806    case MEC_SEA2:              /* 0x2c */
     
    909914        if (wdog_status == init) {
    910915            wdog_status = disabled;
    911916            if (sis_verbose)
    912                 printf("Watchdog disabled\n");
     917                (*sim_callback->printf_filtered) (sim_callback, "Watchdog disabled\n");
    913918        }
    914919        break;
    915920
     
    936941{
    937942    if (dumbio)
    938943        return; /* do nothing */
    939     if (!ifd1)
     944    if (ifd1 == 0 && f1open) {
    940945        tcsetattr(0, TCSANOW, &ioc1);
    941     if (!ifd2)
     946        tcflush(ifd1, TCIFLUSH);
     947    }
     948    if (ifd2 == 0 && f1open) {
    942949        tcsetattr(0, TCSANOW, &ioc2);
     950        tcflush(ifd2, TCIFLUSH);
     951    }
    943952}
    944953
    945954void
     
    947956{
    948957    if (dumbio)
    949958        return; /* do nothing */
    950     if (!ifd1)
     959    if (ifd1 == 0 && f1open && tty_setup)
    951960        tcsetattr(0, TCSANOW, &iocold1);
    952     if (!ifd2)
     961    if (ifd2 == 0 && f2open && tty_setup)
    953962        tcsetattr(0, TCSANOW, &iocold2);
    954963}
    955964
    956965#define DO_STDIO_READ( _fd_, _buf_, _len_ )          \
    957              ( dumbio                               \
     966             ( dumbio || nouartrx \
    958967               ? (0) /* no bytes read, no delay */   \
    959                : read( _fd_, _buf_, _len_ ) )
     968               : (_fd_) == 1 && callback ? \
     969                 callback->read_stdin (callback, _buf_, _len_) :  \
     970                 read( _fd_, _buf_, _len_ ) )
    960971
    961972
    962973static void
     
    976987    }
    977988    if (uart_dev1[0] != 0)
    978989        if ((fd1 = open(uart_dev1, O_RDWR | O_NONBLOCK)) < 0) {
    979             printf("Warning, couldn't open output device %s\n", uart_dev1);
     990            (*sim_callback->printf_filtered) (sim_callback, "Warning, couldn't open output device %s\n", uart_dev1);
    980991        } else {
    981992            if (sis_verbose)
    982                 printf("serial port A on %s\n", uart_dev1);
     993                (*sim_callback->printf_filtered) (sim_callback, "serial port A on %s\n", uart_dev1);
    983994            f1in = f1out = fdopen(fd1, "r+");
    984995            setbuf(f1out, NULL);
    985996            f1open = 1;
    986997        }
    987998    if (f1in) ifd1 = fileno(f1in);
    988999    if (ifd1 == 0) {
     1000        if (callback && !callback->isatty(callback, ifd1)) {
     1001            tty_setup = 0;
     1002        }
    9891003        if (sis_verbose)
    990             printf("serial port A on stdin/stdout\n");
     1004            (*sim_callback->printf_filtered) (sim_callback, "serial port A on stdin/stdout\n");
    9911005        if (!dumbio) {
    9921006            tcgetattr(ifd1, &ioc1);
     1007            if (tty_setup) {
    9931008            iocold1 = ioc1;
    9941009            ioc1.c_lflag &= ~(ICANON | ECHO);
    9951010            ioc1.c_cc[VMIN] = 0;
    9961011            ioc1.c_cc[VTIME] = 0;
    9971012        }
     1013        }
    9981014        f1open = 1;
    9991015    }
    10001016
    10011017    if (f1out) {
    10021018        ofd1 = fileno(f1out);
    1003         if (!dumbio && ofd1 == 1) setbuf(f1out, NULL);
     1019        if (!dumbio && tty_setup && ofd1 == 1) setbuf(f1out, NULL);
    10041020    }
    10051021
    10061022    if (uart_dev2[0] != 0)
    10071023        if ((fd2 = open(uart_dev2, O_RDWR | O_NONBLOCK)) < 0) {
    1008             printf("Warning, couldn't open output device %s\n", uart_dev2);
     1024            (*sim_callback->printf_filtered) (sim_callback, "Warning, couldn't open output device %s\n", uart_dev2);
    10091025        } else {
    10101026            if (sis_verbose)
    1011                 printf("serial port B on %s\n", uart_dev2);
     1027                (*sim_callback->printf_filtered) (sim_callback, "serial port B on %s\n", uart_dev2);
    10121028            f2in = f2out = fdopen(fd2, "r+");
    10131029            setbuf(f2out, NULL);
    10141030            f2open = 1;
     
    10161032    if (f2in)  ifd2 = fileno(f2in);
    10171033    if (ifd2 == 0) {
    10181034        if (sis_verbose)
    1019             printf("serial port B on stdin/stdout\n");
     1035            (*sim_callback->printf_filtered) (sim_callback, "serial port B on stdin/stdout\n");
    10201036        if (!dumbio) {
    10211037            tcgetattr(ifd2, &ioc2);
     1038            if (tty_setup) {
    10221039            iocold2 = ioc2;
    10231040            ioc2.c_lflag &= ~(ICANON | ECHO);
    10241041            ioc2.c_cc[VMIN] = 0;
    10251042            ioc2.c_cc[VTIME] = 0;
    10261043        }
     1044        }
    10271045        f2open = 1;
    10281046    }
    10291047
    10301048    if (f2out) {
    10311049        ofd2 = fileno(f2out);
    1032         if (!dumbio && ofd2 == 1) setbuf(f2out, NULL);
     1050        if (!dumbio && tty_setup && ofd2 == 1) setbuf(f2out, NULL);
    10331051    }
    10341052
    10351053    wnuma = wnumb = 0;
     
    10581076            if (f1open) {
    10591077                anum = DO_STDIO_READ(ifd1, aq, UARTBUF);
    10601078            }
     1079      else {
     1080          anum = 0;
     1081      }
    10611082            if (anum > 0) {
    10621083                aind = 0;
    10631084                if ((aind + 1) < anum)
     
    10901111            if (f2open) {
    10911112                bnum = DO_STDIO_READ(ifd2, bq, UARTBUF);
    10921113            }
     1114            else {
     1115                bnum = 0;
     1116            }
    10931117            if (bnum > 0) {
    10941118                bind = 0;
    10951119                if ((bind + 1) < bnum)
     
    11221146            if (f1open) {
    11231147                anum = DO_STDIO_READ(ifd1, aq, UARTBUF);
    11241148            }
     1149            else {
     1150                anum = 0;
     1151            }
    11251152            if (anum > 0) {
    11261153                Ucontrol |= 0x00000001;
    11271154                aind = 0;
     
    11341161            if (f2open) {
    11351162                bnum = DO_STDIO_READ(ifd2, bq, UARTBUF);
    11361163            }
     1164            else {
     1165                bnum = 0;
     1166            }
    11371167            if (bnum > 0) {
    11381168                Ucontrol |= 0x00010000;
    11391169                bind = 0;
     
    11521182        break;
    11531183    default:
    11541184        if (sis_verbose)
    1155             printf("Read from unimplemented MEC register (%x)\n", addr);
     1185            (*sim_callback->printf_filtered) (sim_callback, "Read from unimplemented MEC register (%x)\n", addr);
    11561186
    11571187    }
    11581188    return 0;
     
    11741204            if (wnuma < UARTBUF)
    11751205                wbufa[wnuma++] = c;
    11761206            else {
    1177                 while (wnuma)
     1207                while (wnuma) {
     1208              if (ofd1 == 1 && callback)
     1209                  wnuma -= callback->write_stdout(callback, wbufa, wnuma);
     1210              else
    11781211                    wnuma -= fwrite(wbufa, 1, wnuma, f1out);
     1212          }
    11791213                wbufa[wnuma++] = c;
    11801214            }
    11811215        }
     
    11981232            if (wnumb < UARTBUF)
    11991233                wbufb[wnumb++] = c;
    12001234            else {
    1201                 while (wnumb)
     1235          while (wnumb) {
     1236              if (ofd1 == 1 && callback)
     1237                  wnumb -= callback->write_stdout(callback, wbufb, wnumb);
     1238              else
    12021239                    wnumb -= fwrite(wbufb, 1, wnumb, f2out);
     1240          }
    12031241                wbufb[wnumb++] = c;
    12041242            }
    12051243        }
     
    12291267        break;
    12301268    default:
    12311269        if (sis_verbose)
    1232             printf("Write to unimplemented MEC register (%x)\n", addr);
     1270            (*sim_callback->printf_filtered) (sim_callback,
     1271                                        "Write to unimplemented MEC register (%x)\n", addr);
    12331272
    12341273    }
    12351274}
     
    12371276static void
    12381277flush_uart()
    12391278{
    1240     while (wnuma && f1open)
     1279    while (wnuma && f1open) {
     1280        if (ofd1 == 1 && callback) {
     1281            wnuma -= callback->write_stdout(callback, wbufa, wnuma);
     1282            callback->flush_stdout(callback);
     1283        }
     1284        else
    12411285        wnuma -= fwrite(wbufa, 1, wnuma, f1out);
    1242     while (wnumb && f2open)
     1286    }
     1287    while (wnumb && f2open) {
     1288        if (ofd2 == 1 && callback) {
     1289            wnuma -= callback->write_stdout(callback, wbufb, wnuma);
     1290            callback->flush_stdout(callback);
     1291        }
     1292        else
    12431293        wnumb -= fwrite(wbufb, 1, wnumb, f2out);
    12441294}
     1295}
    12451296
    12461297
    12471298
    12481299static void
    12491300uarta_tx()
    12501301{
    1251 
    1252     while (f1open && fwrite(&uarta_sreg, 1, 1, f1out) != 1);
     1302    while (f1open) {
     1303        if (ofd1 == 1 && callback) {
     1304            while (callback->write_stdout(callback, &uarta_sreg, 1) != 1);
     1305        }
     1306        else {
     1307            while (fwrite(&uarta_sreg, 1, 1, f1out) != 1);
     1308        }
     1309    }
    12531310    if (uart_stat_reg & UARTA_HRE) {
    12541311        uart_stat_reg |= UARTA_SRE;
    12551312    } else {
     
    12631320static void
    12641321uartb_tx()
    12651322{
    1266     while (f2open && fwrite(&uartb_sreg, 1, 1, f2out) != 1);
     1323    while (f2open) {
     1324        if (ofd2 == 1 && callback) {
     1325            while (callback->write_stdout(callback, &uarta_sreg, 1) != 1);
     1326        }
     1327        else {
     1328            while (fwrite(&uartb_sreg, 1, 1, f2out) != 1);
     1329        }
     1330    }
    12671331    if (uart_stat_reg & UARTB_HRE) {
    12681332        uart_stat_reg |= UARTB_SRE;
    12691333    } else {
     
    12851349    rsize = 0;
    12861350    if (f1open)
    12871351        rsize = DO_STDIO_READ(ifd1, &rxd, 1);
     1352    else
     1353        rsize = 0;
    12881354    if (rsize > 0) {
    12891355        uarta_data = UART_DR | rxd;
    12901356        if (uart_stat_reg & UARTA_HRE)
     
    13011367    rsize = 0;
    13021368    if (f2open)
    13031369        rsize = DO_STDIO_READ(ifd2, &rxd, 1);
     1370    else
     1371        rsize = 0;
    13041372    if (rsize) {
    13051373        uartb_data = UART_DR | rxd;
    13061374        if (uart_stat_reg & UARTB_HRE)
     
    13541422            event(wdog_intr, 0, wdog_scaler + 1);
    13551423        } else {
    13561424            if (wdog_rston) {
    1357                 printf("Watchdog reset!\n");
     1425                (*sim_callback->printf_filtered) (sim_callback, "Watchdog reset!\n");
    13581426                sys_reset();
    13591427                mec_ersr = 0xC000;
    13601428            } else {
     
    13721440{
    13731441    event(wdog_intr, 0, wdog_scaler + 1);
    13741442    if (sis_verbose)
    1375         printf("Watchdog started, scaler = %d, counter = %d\n",
     1443        (*sim_callback->printf_filtered) (sim_callback,
     1444                                    "Watchdog started, scaler = %d, counter = %d\n",
    13761445               wdog_scaler, wdog_counter);
    13771446}
    13781447
     
    13991468        rtc_enabled = 1;
    14001469    } else {
    14011470        if (sis_verbose)
    1402             printf("RTC stopped\n\r");
     1471            (*sim_callback->printf_filtered) (sim_callback,
     1472                                        "RTC stopped\n\r");
    14031473        rtc_enabled = 0;
    14041474    }
    14051475}
     
    14081478rtc_start()
    14091479{
    14101480    if (sis_verbose)
    1411         printf("RTC started (period %d)\n\r", rtc_scaler + 1);
     1481        (*sim_callback->printf_filtered) (sim_callback,
     1482                                    "RTC started (period %d)\n\r", rtc_scaler + 1);
    14121483    event(rtc_intr, 0, rtc_scaler + 1);
    14131484    rtc_scaler_start = now();
    14141485    rtc_enabled = 1;
     
    14521523        gpt_enabled = 1;
    14531524    } else {
    14541525        if (sis_verbose)
    1455             printf("GPT stopped\n\r");
     1526            (*sim_callback->printf_filtered) (sim_callback, "GPT stopped\n\r");
    14561527        gpt_enabled = 0;
    14571528    }
    14581529}
     
    14611532gpt_start()
    14621533{
    14631534    if (sis_verbose)
    1464         printf("GPT started (period %d)\n\r", gpt_scaler + 1);
     1535        (*sim_callback->printf_filtered) (sim_callback,
     1536                                    "GPT started (period %d)\n\r", gpt_scaler + 1);
    14651537    event(gpt_intr, 0, gpt_scaler + 1);
    14661538    gpt_scaler_start = now();
    14671539    gpt_enabled = 1;
     
    15661638    }
    15671639
    15681640    if (sis_verbose)
    1569         printf ("Memory exception at %x (illegal address)\n", addr);
     1641        (*sim_callback->printf_filtered) (sim_callback,
     1642                                    "Memory exception at %x (illegal address)\n", addr);
    15701643    if (sregs.psr & 0x080)
    15711644        asi = 9;
    15721645    else
     
    15891662#ifdef ERRINJ
    15901663    if (errmec) {
    15911664        if (sis_verbose)
    1592             printf("Inserted MEC error %d\n",errmec);
     1665            (*sim_callback->printf_filtered) (sim_callback, "Inserted MEC error %d\n",errmec);
    15931666        set_sfsr(errmec, addr, asi, 1);
    15941667        if (errmec == 5) mecparerror();
    15951668        if (errmec == 6) iucomperr();
     
    16411714    }
    16421715
    16431716    if (sis_verbose)
    1644         printf ("Memory exception at %x (illegal address)\n", addr);
     1717        (*sim_callback->printf_filtered) (sim_callback,
     1718                                    "Memory exception at %x (illegal address)\n", addr);
    16451719    set_sfsr(UIMP_ACC, addr, asi, 1);
    16461720    *ws = MEM_EX_WS;
    16471721    return 1;
     
    16661740#ifdef ERRINJ
    16671741    if (errmec) {
    16681742        if (sis_verbose)
    1669             printf("Inserted MEC error %d\n",errmec);
     1743            (*sim_callback->printf_filtered) (sim_callback,
     1744                                        "Inserted MEC error %d\n",errmec);
    16701745        set_sfsr(errmec, addr, asi, 0);
    16711746        if (errmec == 5) mecparerror();
    16721747        if (errmec == 6) iucomperr();
     
    16901765                 !((mec_wpr[0] && wphit[0]) || (mec_wpr[1] && wphit[1]))
    16911766                 )) {
    16921767                if (sis_verbose)
    1693                     printf("Memory access protection error at 0x%08x\n", addr);
     1768                    (*sim_callback->printf_filtered) (sim_callback,
     1769                                          "Memory access protection error at 0x%08x\n", addr);
    16941770                set_sfsr(PROT_EXC, addr, asi, 0);
    16951771                *ws = MEM_EX_WS;
    16961772                return 1;
  • sim/erc32/exec.c

    diff -ruw gdb-7.11.orig1/sim/erc32/exec.c gdb-7.11/sim/erc32/exec.c
    old new  
    19031903    if (errftt) {
    19041904        sregs->fsr = (sregs->fsr & ~FSR_TT) | (errftt << 14);
    19051905        sregs->fpstate = FP_EXC_PE;
    1906         if (sis_verbose) printf("Inserted fpu error %X\n",errftt);
     1906        if (sis_verbose) (*sim_callback->printf_filtered) (sim_callback,
     1907                                                     "Inserted fpu error %X\n",errftt);
    19071908        errftt = 0;
    19081909    }
    19091910#endif
     
    20232024#ifdef ERRINJ
    20242025    if (errtt) {
    20252026        sregs->trap = errtt;
    2026         if (sis_verbose) printf("Inserted error trap 0x%02X\n",errtt);
     2027        if (sis_verbose) (*sim_callback->printf_filtered) (sim_callback,
     2028                                                     "Inserted error trap 0x%02X\n",errtt);
    20272029        errtt = 0;
    20282030    }
    20292031#endif
  • sim/erc32/func.c

    diff -ruw gdb-7.11.orig1/sim/erc32/func.c gdb-7.11/sim/erc32/func.c
    old new  
    4747char            uart_dev2[128] = "";
    4848extern  int     ext_irl;
    4949uint32          last_load_addr = 0;
     50int             nouartrx = 0;
     51host_callback   *sim_callback;
    5052
    5153#ifdef ERRINJ
    5254uint32          errcnt = 0;
     
    8082    size_t         slen;
    8183
    8284    if ((fp = fopen(fname, "r")) == NULL) {
    83         fprintf(stderr, "couldn't open batch file %s\n", fname);
     85        (*sim_callback->printf_filtered) (sim_callback,
     86                                    "couldn't open batch file %s\n", fname);
    8487        return 0;
    8588    }
    8689    while (getline(&lbuf, &len, fp) > -1) {
    8790        slen = strlen(lbuf);
    8891        if (slen && (lbuf[slen - 1] == '\n')) {
    8992            lbuf[slen - 1] = 0;
    90             printf("sis> %s\n", lbuf);
     93            (*sim_callback->printf_filtered) (sim_callback, "sis> %s\n", lbuf);
    9194            exec_cmd(sregs, lbuf);
    9295        }
    9396    }
     
    279282        err = 1;
    280283    switch (err) {
    281284    case 0:
    282         printf("%s = %d (0x%08x)\n", reg, rval, rval);
     285        (*sim_callback->printf_filtered) (sim_callback, "%s = %d (0x%08x)\n", reg, rval, rval);
    283286        break;
    284287    case 1:
    285         printf("no such regiser: %s\n", reg);
     288        (*sim_callback->printf_filtered) (sim_callback, "no such regiser: %s\n", reg);
    286289        break;
    287290    case 2:
    288         printf("cannot set g0\n");
     291        (*sim_callback->printf_filtered) (sim_callback, "cannot set g0\n");
    289292        break;
    290293    default:
    291294        break;
     
    358361        if ((flim > ebase.simtime) && (flim < 4294967296.0)) {
    359362            lim = (uint32) flim;
    360363        } else  {
    361             printf("error in expression\n");
     364            (*sim_callback->printf_filtered) (sim_callback, "error in expression\n");
    362365            lim = -1;
    363366        }
    364367    }
     
    381384        clen = strlen(cmd1);
    382385        if (strncmp(cmd1, "bp", clen) == 0) {
    383386            for (i = 0; i < sregs->bptnum; i++) {
    384                 printf("  %d : 0x%08x\n", i + 1, sregs->bpts[i]);
     387                (*sim_callback->printf_filtered) (sim_callback, "  %d : 0x%08x\n", i + 1, sregs->bpts[i]);
    385388            }
    386389        } else if (strncmp(cmd1, "+bp", clen) == 0) {
    387390            if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
    388391                sregs->bpts[sregs->bptnum] = VAL(cmd1) & ~0x3;
    389                 printf("added breakpoint %d at 0x%08x\n",
     392                (*sim_callback->printf_filtered) (sim_callback, "added breakpoint %d at 0x%08x\n",
    390393                       sregs->bptnum + 1, sregs->bpts[sregs->bptnum]);
    391394                sregs->bptnum += 1;
    392395            }
     
    394397            if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
    395398                i = VAL(cmd1) - 1;
    396399                if ((i >= 0) && (i < sregs->bptnum)) {
    397                     printf("deleted breakpoint %d at 0x%08x\n", i + 1,
     400                    (*sim_callback->printf_filtered) (sim_callback, "deleted breakpoint %d at 0x%08x\n", i + 1,
    398401                           sregs->bpts[i]);
    399402                    for (; i < sregs->bptnum - 1; i++) {
    400403                        sregs->bpts[i] = sregs->bpts[i + 1];
     
    404407            }
    405408        } else if (strncmp(cmd1, "batch", clen) == 0) {
    406409            if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
    407                 printf("no file specified\n");
     410                (*sim_callback->printf_filtered) (sim_callback, "no file specified\n");
    408411            } else {
    409412                batch(sregs, cmd1);
    410413            }
     
    420423            if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
    421424                sis_verbose = VAL(cmd1);
    422425            }
    423             printf("Debug level = %d\n",sis_verbose);
     426            (*sim_callback->printf_filtered) (sim_callback, "Debug level = %d\n",sis_verbose);
    424427        } else if (strncmp(cmd1, "dis", clen) == 0) {
    425428            if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
    426429                daddr = VAL(cmd1);
     
    429432                len = VAL(cmd2);
    430433            } else
    431434                len = 16;
    432             printf("\n");
     435            (*sim_callback->printf_filtered) (sim_callback, "\n");
    433436            dis_mem(daddr, len, &dinfo);
    434             printf("\n");
     437            (*sim_callback->printf_filtered) (sim_callback, "\n");
    435438            daddr += len * 4;
    436439        } else if (strncmp(cmd1, "echo", clen) == 0) {
    437440            if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL) {
    438                 printf("%s\n", (&cmdsave[clen+1]));
     441                (*sim_callback->printf_filtered) (sim_callback, "%s\n", (&cmdsave[clen+1]));
    439442            }
    440443#ifdef ERRINJ
    441444        } else if (strncmp(cmd1, "error", clen) == 0) {
     
    443446                errper = VAL(cmd1);
    444447                if (errper) {
    445448                    event(errinj, 0, (len = (random()%errper)));
    446                     printf("Error injection started with period %d\n",len);
     449                    (*sim_callback->printf_filtered) (sim_callback, "Error injection started with period %d\n",len);
    447450                }
    448              } else printf("Injected errors: %d\n",errcnt);
     451             } else (*sim_callback->printf_filtered) (sim_callback, "Injected errors: %d\n",errcnt);
    449452#endif
    450453        } else if (strncmp(cmd1, "float", clen) == 0) {
    451454            stat = disp_fpu(sregs);
     
    459462            sregs->npc = sregs->pc + 4;
    460463            if ((sregs->pc != 0) && (ebase.simtime == 0))
    461464                boot_init();
    462             printf("resuming at 0x%08x\n",sregs->pc);
     465            (*sim_callback->printf_filtered) (sim_callback, "resuming at 0x%08x\n",sregs->pc);
    463466            if ((cmd2 = strtok(NULL, " \t\n\r")) != NULL) {
    464467                stat = run_sim(sregs, VAL(cmd2), 0);
    465468            } else {
     
    475478                if (sregs->histbuf != NULL)
    476479                    free(sregs->histbuf);
    477480                sregs->histbuf = (struct histype *) calloc(sregs->histlen, sizeof(struct histype));
    478                 printf("trace history length = %d\n\r", sregs->histlen);
     481                (*sim_callback->printf_filtered) (sim_callback, "trace history length = %d\n\r", sregs->histlen);
    479482                sregs->histind = 0;
    480483
    481484            } else {
     
    483486                for (i = 0; i < sregs->histlen; i++) {
    484487                    if (j >= sregs->histlen)
    485488                        j = 0;
    486                     printf(" %8d ", sregs->histbuf[j].time);
     489                    (*sim_callback->printf_filtered) (sim_callback, " %8d ", sregs->histbuf[j].time);
    487490                    dis_mem(sregs->histbuf[j].addr, 1, &dinfo);
    488491                    j++;
    489492                }
     
    495498                while ((cmd1 = strtok(NULL, " \t\n\r")) != NULL)
    496499                    last_load_addr = bfd_load(cmd1);
    497500            } else {
    498                 printf("load: no file specified\n");
     501                (*sim_callback->printf_filtered) (sim_callback, "load: no file specified\n");
    499502            }
    500503        } else if (strncmp(cmd1, "mem", clen) == 0) {
    501504            if ((cmd1 = strtok(NULL, " \t\n\r")) != NULL)
     
    565568            }
    566569            sregs->pc = len & ~3;
    567570            sregs->npc = sregs->pc + 4;
    568             printf("resuming at 0x%08x\n",sregs->pc);
     571            (*sim_callback->printf_filtered) (sim_callback, "resuming at 0x%08x\n",sregs->pc);
    569572            stat = run_sim(sregs, UINT64_MAX, 0);
    570573            daddr = sregs->pc;
    571574            sim_halt();
    572575        } else if (strncmp(cmd1, "tlimit", clen) == 0) {
    573576           sregs->tlimit = limcalc(sregs->freq);
    574577           if (sregs->tlimit != (uint32) -1)
    575               printf("simulation limit = %u (%.3f ms)\n",(uint32) sregs->tlimit,
     578              (*sim_callback->printf_filtered) (sim_callback, "simulation limit = %u (%.3f ms)\n",(uint32) sregs->tlimit,
    576579                sregs->tlimit / sregs->freq / 1000);
    577580        } else if (strncmp(cmd1, "tra", clen) == 0) {
    578581            if ((cmd1 = strtok(NULL, " \t\n\r")) == NULL) {
     
    580583            } else {
    581584                stat = run_sim(sregs, VAL(cmd1), 1);
    582585            }
    583             printf("\n");
     586            (*sim_callback->printf_filtered) (sim_callback, "\n");
    584587            daddr = sregs->pc;
    585588            sim_halt();
    586589        } else if (strncmp(cmd1, "trun", clen) == 0) {
     
    592595            daddr = sregs->pc;
    593596            sim_halt();
    594597        } else
    595             printf("syntax error\n");
     598            (*sim_callback->printf_filtered) (sim_callback, "syntax error\n");
    596599    }
    597600    if (cmdsave2 != NULL)
    598601        free(cmdsave2);
     
    636639        sregs->nbranch;
    637640#endif
    638641
    639     printf("\n Cycles       : %9" PRIu64 "\n\r", ebase.simtime - sregs->simstart);
    640     printf(" Instructions : %9" PRIu64 "\n", sregs->ninst);
     642    (*sim_callback->printf_filtered) (sim_callback, "\n Cycles       : %9" PRIu64 "\n\r", ebase.simtime - sregs->simstart);
     643    (*sim_callback->printf_filtered) (sim_callback, " Instructions : %9" PRIu64 "\n", sregs->ninst);
    641644
    642645#ifdef STAT
    643     printf("   integer    : %9.2f %%\n", 100.0 * (float) iinst / (float) sregs->ninst);
    644     printf("   load       : %9.2f %%\n",
     646    (*sim_callback->printf_filtered) (sim_callback, "   integer    : %9.2f %%\n", 100.0 * (float) iinst / (float) sregs->ninst);
     647    (*sim_callback->printf_filtered) (sim_callback, "   load       : %9.2f %%\n",
    645648           100.0 * (float) sregs->nload / (float) sregs->ninst);
    646     printf("   store      : %9.2f %%\n",
     649    (*sim_callback->printf_filtered) (sim_callback, "   store      : %9.2f %%\n",
    647650           100.0 * (float) sregs->nstore / (float) sregs->ninst);
    648     printf("   branch     : %9.2f %%\n",
     651    (*sim_callback->printf_filtered) (sim_callback, "   branch     : %9.2f %%\n",
    649652           100.0 * (float) sregs->nbranch / (float) sregs->ninst);
    650     printf("   float      : %9.2f %%\n",
     653    (*sim_callback->printf_filtered) (sim_callback, "   float      : %9.2f %%\n",
    651654           100.0 * (float) sregs->finst / (float) sregs->ninst);
    652     printf(" Integer CPI  : %9.2f\n",
     655    (*sim_callback->printf_filtered) (sim_callback, " Integer CPI  : %9.2f\n",
    653656           ((float) (stime - sregs->pwdtime - sregs->fholdt - sregs->finst))
    654657           /
    655658           (float) (sregs->ninst - sregs->finst));
    656     printf(" Float CPI    : %9.2f\n",
     659    (*sim_callback->printf_filtered) (sim_callback, " Float CPI    : %9.2f\n",
    657660           ((float) sregs->fholdt / (float) sregs->finst) + 1.0);
    658661#endif
    659     printf(" Overall CPI  : %9.2f\n",
     662    (*sim_callback->printf_filtered) (sim_callback, " Overall CPI  : %9.2f\n",
    660663           (float) (stime - sregs->pwdtime) / (float) sregs->ninst);
    661     printf("\n ERC32 performance (%4.1f MHz): %5.2f MOPS (%5.2f MIPS, %5.2f MFLOPS)\n",
     664    (*sim_callback->printf_filtered) (sim_callback, "\n ERC32 performance (%4.1f MHz): %5.2f MOPS (%5.2f MIPS, %5.2f MFLOPS)\n",
    662665           sregs->freq, sregs->freq * (float) sregs->ninst / (float) (stime - sregs->pwdtime),
    663666           sregs->freq * (float) (sregs->ninst - sregs->finst) /
    664667           (float) (stime - sregs->pwdtime),
    665668     sregs->freq * (float) sregs->finst / (float) (stime - sregs->pwdtime));
    666     printf(" Simulated ERC32 time        : %.2f s\n",
     669    (*sim_callback->printf_filtered) (sim_callback, " Simulated ERC32 time        : %.2f s\n",
    667670        (float) (ebase.simtime - sregs->simstart) / 1000000.0 / sregs->freq);
    668     printf(" Processor utilisation       : %.2f %%\n",
     671    (*sim_callback->printf_filtered) (sim_callback, " Processor utilisation       : %.2f %%\n",
    669672        100.0 * (1.0 - ((float) sregs->pwdtime / (float) stime)));
    670     printf(" Real-time performance       : %.2f %%\n",
     673    (*sim_callback->printf_filtered) (sim_callback, " Real-time performance       : %.2f %%\n",
    671674        100.0 / (sregs->tottime / ((double) (stime) / (sregs->freq * 1.0E6))));
    672     printf(" Simulator performance       : %.2f MIPS\n",
     675    (*sim_callback->printf_filtered) (sim_callback, " Simulator performance       : %.2f MIPS\n",
    673676        (double)(sregs->ninst) / sregs->tottime / 1E6);
    674     printf(" Used time (sys + user)      : %.2f s\n\n", sregs->tottime);
     677    (*sim_callback->printf_filtered) (sim_callback, " Used time (sys + user)      : %.2f s\n\n", sregs->tottime);
    675678}
    676679
    677680
     
    692695    int32           sig;
    693696{
    694697    if (sig != 2)
    695         printf("\n\n Signal handler error  (%d)\n\n", sig);
     698        (*sim_callback->printf_filtered) (sim_callback, "\n\n Signal handler error  (%d)\n\n", sig);
    696699    ctrl_c = 1;
    697700}
    698701
     
    721724    int         i;
    722725    float       t;
    723726
    724     printf("\n fsr: %08X\n\n", sregs->fsr);
     727    (*sim_callback->printf_filtered) (sim_callback, "\n fsr: %08X\n\n", sregs->fsr);
    725728
    726729#ifdef HOST_LITTLE_ENDIAN
    727730    for (i = 0; i < 32; i++)
     
    730733
    731734    for (i = 0; i < 32; i++) {
    732735        t = sregs->fs[i];
    733         printf(" f%02d  %08x  %14e  ", i, sregs->fsi[i], sregs->fs[i]);
     736        (*sim_callback->printf_filtered) (sim_callback, " f%02d  %08x  %14e  ", i, sregs->fsi[i], sregs->fs[i]);
    734737        if (!(i & 1))
    735             printf("%14e\n", sregs->fd[i >> 1]);
     738            (*sim_callback->printf_filtered) (sim_callback, "%14e\n", sregs->fd[i >> 1]);
    736739        else
    737             printf("\n");
     740            (*sim_callback->printf_filtered) (sim_callback, "\n");
    738741    }
    739     printf("\n");
     742    (*sim_callback->printf_filtered) (sim_callback, "\n");
    740743    return OK;
    741744}
    742745
     
    749752    int           i;
    750753
    751754    cwp = ((cwp & 0x7) << 4);
    752     printf("\n\t  INS       LOCALS      OUTS     GLOBALS\n");
     755    (*sim_callback->printf_filtered) (sim_callback, "\n\t  INS       LOCALS      OUTS     GLOBALS\n");
    753756    for (i = 0; i < 8; i++) {
    754         printf("   %d:  %08X   %08X   %08X   %08X\n", i,
     757        (*sim_callback->printf_filtered) (sim_callback, "   %d:  %08X   %08X   %08X   %08X\n", i,
    755758               sregs->r[(cwp + i + 24) & 0x7f],
    756759            sregs->r[(cwp + i + 16) & 0x7f], sregs->r[(cwp + i + 8) & 0x7f],
    757760               sregs->g[i]);
     
    776779
    777780    uint32           i;
    778781
    779     printf("\n psr: %08X   wim: %08X   tbr: %08X   y: %08X\n",
     782    (*sim_callback->printf_filtered) (sim_callback, "\n psr: %08X   wim: %08X   tbr: %08X   y: %08X\n",
    780783           sregs->psr, sregs->wim, sregs->tbr, sregs->y);
    781784    sis_memory_read (sregs->pc, (char *) &i, 4);
    782785    printf ("\n  pc: %08X = %08X    ", sregs->pc, i);
     
    785788    printf ("\n npc: %08X = %08X    ", sregs->npc, i);
    786789    print_insn_sparc_sis(sregs->npc, &dinfo);
    787790    if (sregs->err_mode)
    788         printf("\n IU in error mode");
    789     printf("\n\n");
     791        (*sim_callback->printf_filtered) (sim_callback, "\n IU in error mode");
     792    (*sim_callback->printf_filtered) (sim_callback, "\n\n");
    790793}
    791794
    792795static void
     
    804807    char           *p;
    805808
    806809    for (i = addr & ~3; i < ((addr + len) & ~3); i += 16) {
    807         printf("\n %8X  ", i);
     810        (*sim_callback->printf_filtered) (sim_callback, "\n %8X  ", i);
    808811        for (j = 0; j < 4; j++) {
    809812            sis_memory_read ((i + (j * 4)), data.u8, 4);
    810813            printf ("%08x  ", data.u32);
    811814            mem[j] = data.u32;
    812815        }
    813         printf("  ");
     816        (*sim_callback->printf_filtered) (sim_callback, "  ");
    814817        p = (char *) mem;
    815818        for (j = 0; j < 16; j++) {
    816819            if (isprint (p[j ^ EBT]))
     
    819822                putchar('.');
    820823        }
    821824    }
    822     printf("\n\n");
     825    (*sim_callback->printf_filtered) (sim_callback, "\n\n");
    823826}
    824827
    825828void
     
    839842        printf (" %08x  %08x  ", i, data.u32);
    840843        print_insn_sparc_sis(i, info);
    841844        if (i >= 0xfffffffc) break;
    842         printf("\n");
     845        (*sim_callback->printf_filtered) (sim_callback, "\n");
    843846    }
    844847}
    845848
     
    854857    struct evcell  *ev1, *evins;
    855858
    856859    if (ebase.freeq == NULL) {
    857         printf("Error, too many events in event queue\n");
     860        (*sim_callback->printf_filtered) (sim_callback, "Error, too many events in event queue\n");
    858861        return;
    859862    }
    860863    ev1 = &ebase.eq;
     
    959962    uint64          endtime;
    960963
    961964    if (ebase.eq.nxt == NULL)
    962         printf("Warning: event queue empty - power-down mode not entered\n");
     965        (*sim_callback->printf_filtered) (sim_callback, "Warning: event queue empty - power-down mode not entered\n");
    963966    endtime = ebase.simtime;
    964967    while (!ext_irl && (ebase.eq.nxt != NULL)) {
    965968        ebase.simtime = ebase.eq.nxt->time;
     
    971974        ebase.freeq = evrem;
    972975        cfunc(arg);
    973976        if (ctrl_c) {
    974             printf("\bwarning: power-down mode interrupted\n");
     977            (*sim_callback->printf_filtered) (sim_callback, "\bwarning: power-down mode interrupted\n");
    975978            break;
    976979        }
    977980    }
     
    10391042    pbfd = bfd_openr(fname, 0);
    10401043
    10411044    if (pbfd == NULL) {
    1042         printf("open of %s failed\n", fname);
     1045        (*sim_callback->printf_filtered) (sim_callback, "open of %s failed\n", fname);
    10431046        return -1;
    10441047    }
    10451048    if (!bfd_check_format(pbfd, bfd_object)) {
    1046         printf("file %s  doesn't seem to be an object file\n", fname);
     1049        (*sim_callback->printf_filtered) (sim_callback, "file %s  doesn't seem to be an object file\n", fname);
    10471050        return -1;
    10481051    }
    10491052
    10501053    arch = bfd_get_arch_info (pbfd);
    10511054    if (sis_verbose)
    1052         printf("loading %s:", fname);
     1055        (*sim_callback->printf_filtered) (sim_callback, "loading %s:", fname);
    10531056    for (section = pbfd->sections; section; section = section->next) {
    10541057        if (bfd_get_section_flags(pbfd, section) & SEC_ALLOC) {
    10551058            bfd_vma         section_address;
     
    10871090            section_size = bfd_section_size(pbfd, section);
    10881091
    10891092            if (sis_verbose)
    1090                 printf("\nsection %s at 0x%08lx (0x%lx bytes)",
     1093                (*sim_callback->printf_filtered) (sim_callback, "\nsection %s at 0x%08lx (0x%lx bytes)",
    10911094                       section_name, section_address, section_size);
    10921095
    10931096            /* Text, data or lit */
     
    11131116                }
    11141117            } else              /* BSS */
    11151118                if (sis_verbose)
    1116                     printf("(not loaded)");
     1119                    (*sim_callback->printf_filtered) (sim_callback, "(not loaded)");
    11171120        }
    11181121    }
    11191122    if (sis_verbose)
    1120         printf("\n");
     1123        (*sim_callback->printf_filtered) (sim_callback, "\n");
    11211124
    11221125    return bfd_get_start_address (pbfd);
    11231126}
  • sim/erc32/interf.c

    diff -ruw gdb-7.11.orig1/sim/erc32/interf.c gdb-7.11/sim/erc32/interf.c
    old new  
    5757
    5858int             sis_gdb_break = 1;
    5959
    60 host_callback *sim_callback;
    61 
    6260int
    6361run_sim(sregs, icount, dis)
    6462    struct pstate  *sregs;
     
    8987#if 0   /* DELETE ME! for debugging purposes only */
    9088        if (sis_verbose > 1)
    9189            if (sregs->pc == 0 || sregs->npc == 0)
    92                 printf ("bogus pc or npc\n");
     90                (*sim_callback->printf_filtered) (sim_callback, "bogus pc or npc\n");
    9391#endif
    9492        mexc = memory_iread (sregs->pc, &sregs->inst, &sregs->hold);
    9593#if 0   /* DELETE ME! for debugging purposes only */
    9694        if (sis_verbose > 2)
    97             printf("pc %x, np %x, sp %x, fp %x, wm %x, cw %x, i %08x\n",
     95            (*sim_callback->printf_filtered) (sim_callback, "pc %x, np %x, sp %x, fp %x, wm %x, cw %x, i %08x\n",
    9896                   sregs->pc, sregs->npc,
    9997                   sregs->r[(((sregs->psr & 7) << 4) + 14) & 0x7f],
    10098                   sregs->r[(((sregs->psr & 7) << 4) + 30) & 0x7f],
     
    192190            if (strcmp(argv[stat], "-dumbio") == 0) {
    193191                dumbio = 1;
    194192            } else
     193            if (strcmp(argv[stat], "-nouartrx") == 0) {
     194                nouartrx = 1;
     195            } else
    195196            if (strcmp(argv[stat], "-wrp") == 0) {
    196197                wrp = 1;
    197198            } else
     
    430431#if 1
    431432      if (sis_verbose > 2) {
    432433        uint32 fp = sregs.r[(win * 16 + 30) & 0x7f];
    433         printf("flush_window: win %d, sp %x, fp %x\n", win, sp, fp);
     434        (*sim_callback->printf_filtered) (sim_callback, "flush_window: win %d, sp %x, fp %x\n", win, sp, fp);
    434435      }
    435436#endif
    436437
  • sim/erc32/sis.c

    diff -ruw gdb-7.11.orig1/sim/erc32/sis.c gdb-7.11/sim/erc32/sis.c
    old new  
    199199#endif
    200200            } else if (strcmp(argv[stat], "-dumbio") == 0) {
    201201                dumbio = 1;
     202            } else if (strcmp(argv[stat], "-nouartrx") == 0) {
     203                nouartrx = 1;
    202204            } else {
    203205                printf("unknown option %s\n", argv[stat]);
    204206                usage();
     
    293295    }
    294296    return 0;
    295297}
    296 
  • sim/erc32/sis.h

    diff -ruw gdb-7.11.orig1/sim/erc32/sis.h gdb-7.11/sim/erc32/sis.h
    old new  
    158158/* Prototypes  */
    159159
    160160/* erc32.c */
    161 extern void     init_sim (void);
     161extern void     init_sim ();
    162162extern void     reset (void);
    163163extern void     error_mode (uint32 pc);
    164164extern void     sim_halt (void);
     
    200200extern void     sys_halt (void);
    201201extern int      bfd_load (const char *fname);
    202202extern double   get_time (void);
     203extern int      nouartrx;
     204extern host_callback *sim_callback;
    203205
    204206/* exec.c */
    205207extern int      dispatch_instruction (struct pstate *sregs);
Note: See TracBrowser for help on using the repository browser.