Ticket #3460: gdb-8.2.1-sis-2.12.patch

File gdb-8.2.1-sis-2.12.patch, 16.1 KB (added by Sebastian Huber, on 02/08/19 at 09:21:36)

  • sim/sis/exec.c 

    From 65028ea86dd305523e812809f3619ff4767cc830 Mon Sep 17 00:00:00 2001
From: Jiri Gaisler <jiri@gaisler.se>
Date: Thu, 7 Feb 2019 14:49:28 +0100
Subject: [PATCH] sis: improve debug of SMP systems

---
 sim/sis/exec.c   |  2 +-
 sim/sis/func.c   | 91 +++++++++++++++++++++++++++++++-----------------
 sim/sis/interf.c | 35 ++++++++-----------
 sim/sis/riscv.h  | 13 +++++--
 sim/sis/sis.c    | 29 ++++++++++-----
 sim/sis/sis.h    |  7 +++-
 sim/sis/sparc.h  |  8 ++++-
 7 files changed, 119 insertions(+), 66 deletions(-)

diff --git a/sim/sis/exec.c b/sim/sis/exec.c
index c885095685..262a080dea 100644
    a b init_regs(sregs) 
    122122{
    123123  int i;
    124124
    125   ebase.bphit = 0;
    126125  ebase.wphit = 0;
    127126  ebase.lrq = 0;
    128127
    … … init_regs(sregs) 
    177176    sregs[i].mpp = 0;
    178177    sregs[i].mode = 1;
    179178    sregs[i].lrq = 0;
     179    sregs[i].bphit = 0;
    180180  }
    181181}
    182182

  • sim/sis/func.c 

    diff --git a/sim/sis/func.c b/sim/sis/func.c
index 5aac9c6811..7ab55b4c7f 100644
    a b struct evcell evbuf[EVENT_MAX]; 
    4141
    4242int             ctrl_c = 0;
    4343int             sis_verbose = 0;
    44 char           *sis_version = "2.11";
     44char           *sis_version = "2.12";
    4545int             nfp = 0;
    4646int             ift = 0;
    4747int             wrp = 0;
    … … exec_cmd(const char *cmd) 
    381381            reset_all();
    382382            reset_stat(sregs);
    383383            if (last_load_addr != 0) {
    384                 sregs->pc = last_load_addr & ~1;
    385                 sregs->npc = sregs->pc + 4;
     384                for (i=0; i<ncpu; i++) {
     385                  sregs[i].pc = last_load_addr & ~3;
     386                  sregs[i].npc = sregs[i].pc + 4;
     387                }
    386388            }
    387389            if ((sregs->pc != 0) && (ebase.simtime == 0)) ms->boot_init ();
    388390            ebase.tlimit = limcalc(ebase.freq);
    … … check_bpt(sregs) 
    768770{
    769771    int32           i;
    770772
    771     if (ebase.bphit)
     773    if (sregs->bphit) {
     774        sregs->bphit = 0;
    772775        return 0;
     776    }
    773777    for (i = 0; i < (int32) ebase.bptnum; i++) {
    774778        if (sregs->pc == ebase.bpts[i])
    775779            return BPT_HIT;
    … … sys_halt() 
    839843/* simulate uni-processor system */
    840844
    841845static int
    842 run_sim_un(icount, dis)
     846run_sim_un(sregs, icount, dis)
     847    struct pstate  *sregs;
    843848    uint64          icount;
    844849    int             dis;
    845850{
    … … run_sim_un(icount, dis) 
    851856    while (icount > 0) {
    852857        if (sregs->pwd_mode) {
    853858            sregs->simtime = ebase.evtime; /* skip forward to next event */
    854             if (ext_irl[0]) irq = check_interrupts(sregs);
     859            if (ext_irl[sregs->cpu]) irq = check_interrupts(sregs);
    855860        } else {
    856861            sregs->icnt = 1;
    857862            sregs->fhold = 0;
    858             if (ext_irl[0]) irq = check_interrupts(sregs);
     863            if (ext_irl[sregs->cpu]) irq = check_interrupts(sregs);
    859864            if (!irq) {
    860865                mexc = ms->memory_iread (sregs->pc, &sregs->inst, &sregs->hold);
    861866                if (mexc) {
    862867                    sregs->trap = I_ACC_EXC;
    863868                } else {
    864869                    if (deb) {
    865                         if (ebase.histlen) {
     870                        if ((ebase.bptnum) && (sregs->bphit = check_bpt(sregs)))
     871                            icount = 0;
     872                        else {
     873                          if (ebase.histlen) {
    866874                            sregs->histbuf[sregs->histind].addr = sregs->pc;
    867875                            sregs->histbuf[sregs->histind].time = ebase.simtime;
    868876                            sregs->histind++;
    869877                            if (sregs->histind >= ebase.histlen)
    870878                                sregs->histind = 0;
    871                         }
    872                         if (dis) {
     879                          }
     880                          if (dis) {
    873881                            printf(" %8" PRIu64 " ", ebase.simtime);
    874882                            dis_mem(sregs->pc, 1, &dinfo);
    875                         }
    876                         if ((ebase.bptnum) && (ebase.bphit = check_bpt(sregs)))
    877                             icount = 0;
    878                         else {
     883                          }
    879884                            dispatch_instruction(sregs);
    880885                            icount--;
    881886                        }
    … … run_sim_un(icount, dis) 
    892897                    sregs->err_mode = 0;
    893898                    sregs->trap = 0;
    894899                    icount = 0;
     900                    ebase.bpcpu = sregs->cpu;
     901                    if (ebase.histlen) {
     902                        sregs->histind--;
     903                        if (sregs->histind >= ebase.histlen)
     904                            sregs->histind = ebase.histlen - 1;
     905                    }
    895906                }
    896907                if (sregs->err_mode) {
    897908                    ms->error_mode (sregs->pc);
    898909                    icount = 0;
     910                    ebase.bpcpu = sregs->cpu;
    899911                }
    900912            }
    901913#ifdef STAT
    … … run_sim_un(icount, dis) 
    912924    }
    913925    if (sregs->err_mode)
    914926        return ERROR;
    915     if (ebase.bphit)
     927    if (sregs->bphit)
    916928        return (BPT_HIT);
    917929    if (ebase.wphit)
    918930        return (WPT_HIT);
    … … run_sim_core(sregs, ntime, deb, dis) 
    955967                    sregs->trap = I_ACC_EXC;
    956968                } else {
    957969                    if (deb) {
     970                        if ((ebase.bptnum) && (sregs->bphit = check_bpt(sregs))) {
     971                            ntime = sregs->simtime;
     972                            ctrl_c = 1;
     973                            ebase.bpcpu = sregs->cpu;
     974                            break;
     975                        }
    958976                        if (ebase.histlen) {
    959977                            sregs->histbuf[sregs->histind].addr = sregs->pc;
    960978                            sregs->histbuf[sregs->histind].time = sregs->simtime;
    … … run_sim_core(sregs, ntime, deb, dis) 
    966984                            printf("cpu %d  %8" PRIu64 " ", sregs->cpu, sregs->simtime);
    967985                            dis_mem(sregs->pc, 1, &dinfo);
    968986                        }
    969                         if ((ebase.bptnum) && (ebase.bphit = check_bpt(sregs))) {
    970                             ntime = sregs->simtime;
    971                         } else {
    972                             dispatch_instruction(sregs);
    973                         }
     987                        dispatch_instruction(sregs);
    974988                    } else {
    975989                        dispatch_instruction(sregs);
    976990                    }
    … … run_sim_core(sregs, ntime, deb, dis) 
    984998                    sregs->trap = 0;
    985999                    ntime = sregs->simtime;
    9861000                    ctrl_c = 1;
     1001                    ebase.bpcpu = sregs->cpu;
     1002                    if (ebase.histlen) {
     1003                        sregs->histind--;
     1004                        if (sregs->histind >= ebase.histlen)
     1005                            sregs->histind = ebase.histlen - 1;
     1006                    }
    9871007                    break;
    9881008                }
    9891009                if (sregs->err_mode) {
    … … run_sim_core(sregs, ntime, deb, dis) 
    9921012                    sregs->pwdstart = sregs->simtime;
    9931013                    sregs->simtime = ntime;
    9941014                    ctrl_c = 1;
     1015                    ebase.bpcpu = sregs->cpu;
    9951016                    break;
    9961017                }
    9971018            }
    … … run_sim_core(sregs, ntime, deb, dis) 
    10021023#endif
    10031024            sregs->simtime += sregs->icnt + sregs->hold + sregs->fhold;
    10041025          }
    1005         else
     1026        else {
    10061027            sregs->simtime = ntime;
    10071028            if (ext_irl[sregs->cpu]) irq = check_interrupts(sregs);
     1029        }
    10081030}
    10091031
    10101032/* time slice simulation of cpu cores in MP system */
    … … run_sim_mp(icount, dis) 
    10141036    uint64          icount;
    10151037    int             dis;
    10161038{
    1017     uint64          ntime;
     1039    uint64          ntime, etime;
    10181040    int             deb, i;
    1019     int             err_mode, bphit, wphit;
     1041    int             err_mode, bphit, wphit, oldcpu;
    10201042
    10211043    err_mode = bphit = wphit = 0;
    10221044    icount += ebase.simtime;
    … … run_sim_mp(icount, dis) 
    10311053      if (ntime > icount) ntime = icount;
    10321054      for(i=0; i<ncpu; i++) {
    10331055        deb = dis || ebase.histlen || ebase.bptnum;
     1056        etime = ntime;
    10341057        run_sim_core(&sregs[i], ntime, deb, dis);
    10351058        err_mode |= sregs[i].err_mode;
    1036         bphit |= ebase.bphit;
     1059        bphit |= sregs[i].bphit;
    10371060        wphit |= ebase.wphit;
     1061        if (sregs[i].simtime < etime)
     1062            etime = sregs[i].simtime;
    10381063      }
    1039       advance_time(ntime);
     1064      advance_time(etime);
    10401065      if (ctrl_c) {
    10411066          icount = 0;
    10421067      }
    10431068    }
    1044     /* align time of all cores to allow single stepping */
    1045     for(i=0; i<ncpu; i++) {
    1046         sregs[i].simtime = ebase.simtime;
    1047     }
     1069
     1070    oldcpu = cpu;
     1071    cpu = ebase.bpcpu;
     1072    if (err_mode == NULL_HIT)
     1073        return NULL_HIT;
    10481074    if (err_mode)
    10491075        return ERROR;
    10501076    if (bphit)
    … … run_sim_mp(icount, dis) 
    10541080    if (ctrl_c) {
    10551081        return CTRL_C;
    10561082    }
     1083    cpu = oldcpu;
    10571084    return TIME_OUT;
    10581085}
    10591086
    … … run_sim(icount, dis) 
    10711098        event(sim_timeout, 2, ebase.tlimit - ebase.simtime);
    10721099    if (ebase.coven)
    10731100        cov_start(sregs[0].pc);
    1074     if (ncpu > 1)
    1075         res = run_sim_mp(icount, dis);
     1101    if ((ncpu == 1) || (icount == 1))
     1102        res = run_sim_un(&sregs[cpu], icount, dis);
    10761103    else
    1077         res = run_sim_un(icount, dis);
     1104        res = run_sim_mp(icount, dis);
    10781105    remove_event(sim_timeout);
    10791106    ebase.tottime += get_time() - ebase.starttime;
    10801107    ms->restore_stdio ();

  • sim/sis/interf.c 

    diff --git a/sim/sis/interf.c b/sim/sis/interf.c
index 964304e585..ac85fc0d22 100644
    a b run_sim_gdb(icount, dis) 
    4545
    4646    if (sis_verbose)
    4747        (*sim_callback->printf_filtered) (sim_callback, "resuming at %x\n",
    48                                           sregs->pc);
    49     if ((sregs->pc != 0) && (ebase.simtime == 0))
     48                                          sregs[cpu].pc);
     49    if ((sregs[cpu].pc != 0) && (ebase.simtime == 0))
    5050        ms->boot_init ();
    5151    res = run_sim(icount, dis);
    5252    clearerr(stdin);
    … … sim_store_register(sd, regno, value, length) 
    249249
    250250    regval = (value[0] << 24) | (value[1] << 16)
    251251                 | (value[2] << 8) | value[3];
    252     set_regi(sregs, regno, regval);
     252    set_regi(&sregs[cpu], regno, regval);
    253253    return length;
    254254}
    255255
    … … sim_fetch_register(sd, regno, buf, length) 
    261261    unsigned char  *buf;
    262262     int length;
    263263{
    264     get_regi(sregs, regno, buf, length);
     264    get_regi(&sregs[cpu], regno, buf, length);
    265265    return -1;
    266266}
    267267
    … … sim_info(sd, verbose) 
    292292     SIM_DESC sd;
    293293     int verbose;
    294294{
    295     show_stat(sregs);
     295    show_stat(&sregs[cpu]);
    296296}
    297297
    298298int             simstat = OK;
    … … sim_stop_reason(sd, reason, sigrc) 
    319319        *reason = sim_stopped;
    320320        *sigrc = GDB_SIGNAL_TRAP;
    321321        break;
     322    case NULL_HIT:
     323        *reason = sim_stopped;
     324        *sigrc = 11;
     325        break;
    322326    case ERROR:
    323327        *sigrc = 0;
    324328        *reason = sim_exited;
    … … sim_resume(SIM_DESC sd, int step, int siggnal) 
    334338{
    335339    if (sis_verbose)
    336340        (*sim_callback->printf_filtered) (sim_callback,
    337             "sim_resume_start %x : %x : %x : %x : 0x%08x\n", step, siggnal, ebase.bphit, ebase.wphit, sregs[0].pc);
    338     if (step) {
    339         ebase.bphit = 0;
    340         ebase.wphit = 1;
    341         simstat = run_sim_gdb(1, 0);
    342         ebase.bphit = 0;
    343         ebase.wphit = 0;
    344     } else if (ebase.bphit || ebase.wphit) {
    345         ebase.bphit = 0;
    346         ebase.wphit = 1;
     341            "sim_resume_start %x : %x : %x : %x : 0x%08x\n",
     342             step, siggnal, sregs[cpu].bphit, ebase.wphit, sregs[cpu].pc);
     343    if (step)
    347344        simstat = run_sim_gdb(1, 0);
    348         ebase.bphit = ebase.wphit = 0;
    349         simstat = run_sim_gdb(UINT64_MAX/2, 0);
    350         ebase.bphit = 0;
    351     }
    352345    else
    353346        simstat = run_sim_gdb(UINT64_MAX/2, 0);
    354347
    355348    if (sis_verbose)
    356349        (*sim_callback->printf_filtered) (sim_callback,
    357             "sim_resume_end %x : %x : %x : %x : %x : 0x%08x\n", step, siggnal, ebase.bphit, ebase.wphit, simstat, sregs[0].pc);
    358     if (sis_gdb_break) flush_windows (sregs);
     350            "sim_resume_end %x : %x : %x : %x : %x : 0x%08x\n", step, siggnal, sregs[cpu].bphit, ebase.wphit, simstat, sregs[cpu].pc);
     351    if (sis_gdb_break) flush_windows (&sregs[cpu]);
    359352}
    360353
    361354void

  • sim/sis/riscv.h 

    diff --git a/sim/sis/riscv.h b/sim/sis/riscv.h
index 6a77e8d1fd..a624b6b908 100644
    a b dispatch_instruction (sregs) 
    481481                sregs->g[1] = npc;
    482482              npc = sregs->pc + offset;
    483483              npc &= ~1;
     484              if (!npc)
     485                sregs->trap = NULL_TRAP;        // halt on null pointer
    484486              if (ebase.coven)
    485487                cov_jmp (sregs->pc, npc);
    486488              break;
    … … dispatch_instruction (sregs) 
    684686                      if (sis_gdb_break)
    685687                        {
    686688                          sregs->trap = WPT_TRAP;
    687                           ebase.bphit = 1;
     689                          sregs->bphit = 1;
    688690                        }
    689691                      else
    690692                        sregs->trap = TRAP_EBREAK;
    … … dispatch_instruction (sregs) 
    852854          sregs->g[rd] = npc;
    853855          npc = sregs->pc + offset;
    854856          npc &= ~1;
     857          if (!npc)
     858            sregs->trap = NULL_TRAP;    // halt on null pointer
    855859          if (ebase.coven)
    856860            cov_jmp (sregs->pc, npc);
    857861          break;
    … … dispatch_instruction (sregs) 
    864868          sregs->g[rd] = npc;
    865869          npc = op1 + offset;
    866870          npc &= ~1;
     871          if (!npc)
     872            sregs->trap = NULL_TRAP;    // halt on null pointer
    867873          if (ebase.coven)
    868874            cov_jmp (sregs->pc, npc);
    869875          sregs->icnt += T_JALR;
    … … dispatch_instruction (sregs) 
    14031409                  if (sis_gdb_break)
    14041410                    {
    14051411                      sregs->trap = WPT_TRAP;
    1406                       ebase.bphit = 1;
     1412                      sregs->bphit = 1;
    14071413                    }
    14081414                  else
    14091415                    sregs->trap = TRAP_EBREAK;
    … … execute_trap (sregs) 
    20362042          return (ERROR);
    20372043        case WPT_TRAP:
    20382044          return (WPT_HIT);
     2045        case NULL_TRAP:
     2046          return (NULL_HIT);
     2047
    20392048        }
    20402049    }
    20412050  else

  • sim/sis/sis.c 

    diff --git a/sim/sis/sis.c b/sim/sis/sis.c
index 398da65bc3..0052e3768c 100644
    a b main(argc, argv) 
    5555    int             lfile = 0;
    5656    char            tlim[64] = "";
    5757    int             run = 0;
     58    char            prompt[8];
    5859
    5960    cfile = 0;
    6061    for (i = 0; i < 64; i++)
    6162        cmdq[i] = 0;
    62     printf("\n SIS - SPARC/RISCV instruction simulator %s,  copyright Jiri Gaisler 1995\n", sis_version);
     63    printf("\n SIS - SPARC/RISCV instruction simulator %s,  copyright Jiri Gaisler 2019\n", sis_version);
    6364    printf (" Bug-reports to jiri@gaisler.se\n\n");
    6465    while (stat < argc) {
    6566        if (argv[stat][0] == '-') {
    … … main(argc, argv) 
    203204            cont = 0;
    204205        }
    205206        else {
    206             cmdq[cmdi] = readline("sis> ");
     207            if (ncpu > 1)
     208                sprintf(prompt, "cpu%d> ", cpu);
     209            else
     210                sprintf(prompt, "sis> ");
     211            cmdq[cmdi] = readline(prompt);
    207212            if (cmdq[cmdi] && *cmdq[cmdi])
    208213                add_history(cmdq[cmdi]);
    209214            if (cmdq[cmdi])
    … … main(argc, argv) 
    223228              ((double) ebase.simtime / (double) ebase.freq) / 1000.0);
    224229            break;
    225230        case BPT_HIT:
    226             printf("breakpoint at 0x%08x reached\n", sregs[0].pc);
    227             ebase.bphit = 1;
     231            printf("cpu %d breakpoint at 0x%08x reached\n",
     232                ebase.bpcpu, sregs[ebase.bpcpu].pc);
    228233            break;
    229234        case ERROR:
    230             printf("IU in error mode (%d)\n", sregs[0].trap);
     235            printf("cpu %d in error mode (tt = 0x%02x)\n",
     236                ebase.bpcpu, sregs[ebase.bpcpu].trap);
    231237            stat = 0;
    232238            printf(" %8" PRIu64 " ", ebase.simtime);
    233             dis_mem(sregs[0].pc, 1, &dinfo);
     239            dis_mem(sregs[cpu].pc, 1, &dinfo);
    234240            break;
    235241        case WPT_HIT:
    236             printf("watchpoint at 0x%08x reached, pc = 0x%08x\n",
    237                 ebase.wpaddress, sregs[0].pc);
     242            printf("cpu %d watchpoint at 0x%08x reached, pc = 0x%08x\n",
     243                ebase.bpcpu, ebase.wpaddress, sregs[ebase.bpcpu].pc);
    238244            ebase.wphit = 1;
    239245            break;
     246        case NULL_HIT:
     247            printf("null pointer dereferenced, cpu %d in error mode\n",
     248                ebase.bpcpu);
     249            stat = 0;
     250            printf(" %8" PRIu64 " ", ebase.simtime);
     251            dis_mem(sregs[cpu].pc, 1, &dinfo);
     252            break;
    240253        case QUIT:
    241254            cont = 0;
    242255            break;

  • sim/sis/sis.h 

    diff --git a/sim/sis/sis.h b/sim/sis/sis.h
index edb5023938..1d241b33b3 100644
    a b struct pstate { 
    161161    uint64          mtimecmp;
    162162    uint32          lrq;
    163163    uint32          lrqa;
     164
     165    uint32          bphit;
    164166};
    165167
    166168struct evcell {
    … … struct estate { 
    181183    uint64          simstart;
    182184    uint64          tlimit;     /* Simulation time limit */
    183185    uint32          bptnum;
    184     uint32          bphit;
    185186    uint32          bpts[BPT_MAX];      /* Breakpoints */
    186187    uint32          wprnum;
    187188    uint32          wphit;
    … … struct estate { 
    195196    uint32          lrq;
    196197    uint32          coven;              /* coverage enable */
    197198    uint32          ramstart;           /* start of RAM */
     199    uint32          bpcpu;              /* cpu that hit breakpoint */
    198200};
    199201
    200202/* return values for run_sim */
    … … struct estate { 
    204206#define ERROR 3
    205207#define CTRL_C 4
    206208#define WPT_HIT 5
     209#define NULL_HIT 6
    207210#define QUIT 10
    208211
    209212/* special simulator trap types */
    210213#define ERROR_TRAP 257
    211214#define WPT_TRAP   258
     215#define NULL_TRAP   259
    212216
    213217/* cpu type defines */
    214218#define CPU_LEON2  2
    … … extern int dumbio; 
    270274extern int      tty_setup;
    271275extern int      cputype;
    272276extern int      sis_gdb_break;
     277extern int      cpu;    /* active debug cpu */
    273278extern int      ncpu;   /* number of online cpus */
    274279extern int      delta;  /* time slice for MP simulation */
    275280extern void     pwd_enter(struct pstate *sregs);

  • sim/sis/sparc.h 

    diff --git a/sim/sis/sparc.h b/sim/sis/sparc.h
index 9954a6f522..d90c1a7406 100644
    a b dispatch_instruction(sregs) 
    652652                                (sregs->inst == 0x91d02001))
    653653                    {
    654654                        sregs->trap = WPT_TRAP;
    655                         ebase.bphit = 1;
     655                        sregs->bphit = 1;
    656656                    }
    657657                }
    658658                break;
    … … dispatch_instruction(sregs) 
    10141014                }
    10151015                *rdd = sregs->pc;
    10161016                npc = rs1 + operand2;
     1017                if (!npc)
     1018                    sregs->trap = NULL_TRAP;    // halt on null pointer
    10171019                if (ebase.coven) {
    10181020                  cov_jmp(sregs->pc, npc);
    10191021                  cov_exec(pc);  /* delay slot executed */
    … … dispatch_instruction(sregs) 
    10391041                    sregs->trap = TRAP_UNALI;
    10401042                    break;
    10411043                }
     1044                if (!address)
     1045                    sregs->trap = NULL_TRAP;    // halt on null pointer
    10421046                sregs->psr = (sregs->psr & ~PSR_CWP) | new_cwp | PSR_ET;
    10431047                sregs->psr =
    10441048                    (sregs->psr & ~PSR_S) | ((sregs->psr & PSR_PS) << 1);
    … … execute_trap(sregs) 
    18501854            return (ERROR);
    18511855        case WPT_TRAP:
    18521856            return (WPT_HIT);
     1857        case NULL_TRAP:
     1858            return (NULL_HIT);
    18531859        }
    18541860    } else {
    18551861