[simh.git] / PDP10 / pdp10_pag.c

/* pdp10_pag.c: PDP-10 paging subsystem simulator\r
\r
   Copyright (c) 1993-2005, Robert M Supnik\r
\r
   Permission is hereby granted, free of charge, to any person obtaining a\r
   copy of this software and associated documentation files (the "Software"),\r
   to deal in the Software without restriction, including without limitation\r
   the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
   and/or sell copies of the Software, and to permit persons to whom the\r
   Software is furnished to do so, subject to the following conditions:\r
\r
   The above copyright notice and this permission notice shall be included in\r
   all copies or substantial portions of the Software.\r
\r
   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
   IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
   FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL\r
   ROBERT M SUPNIK BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
   IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
   CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
\r
   Except as contained in this notice, the name of Robert M Supnik shall not be\r
   used in advertising or otherwise to promote the sale, use or other dealings\r
   in this Software without prior written authorization from Robert M Supnik.\r
\r
   pag          KS10 pager\r
\r
   22-Sep-05    RMS     Fixed declarations (from Sterling Garwood)\r
   02-Dec-01    RMS     Fixed bug in ITS LPMR (found by Dave Conroy)\r
   21-Aug-01    RMS     Fixed bug in ITS paging (found by Miriam Lennox)\r
                        Removed register from declarations\r
   19-May-01    RMS     Added workaround for TOPS-20 V4.1 boot bug\r
   03-May-01    RMS     Fixed bug in indirect page table pointer processing\r
   29-Apr-01    RMS     Added CLRCSH for ITS, fixed LPMR\r
\r
   The pager consists of a standard hardware part (the translation\r
   tables) and an operating-system specific page table fill routine.\r
\r
   There are two translation tables, one for executive mode and one\r
   for user mode.  Each table consists of 512 page table entries,\r
   one for each page in the 18b virtual address space.  Each pte\r
   contains (in the hardware) a valid bit, a writeable bit, an\r
   address space bit (executive or user), and a cacheable bit, plus\r
   the physical page number corresponding to the virtual page.  In\r
   the simulator, the pte is expanded for rapid processing of normal\r
   reads and writes.  An expanded pte contains a valid bit, a writeable\r
   bit, and the physical page number shifted left by the page size.\r
\r
        Expanded pte            meaning\r
        0                       invalid\r
        >0                      read only\r
        <0                      read write\r
\r
   There is a third, physical table, which is used in place of the\r
   executive and user tables if paging is off.  Its entries are always\r
   valid and always writeable.\r
\r
   To translate a virtual to physical address, the simulator uses\r
   the virtual page number to index into the appropriate page table.\r
   If the page table entry (pte) is not valid, the page fill routine\r
   is called to see if the entry is merely not filled or is truly\r
   inaccessible.  If the pte is valid but not writeable, and the\r
   reference is a write reference, the page fill routine is also\r
   called to see if the reference can be resolved.\r
\r
   The page fill routine is operating system dependent.  Three styles\r
   of paging are supported:\r
\r
        TOPS10          known in the KS10 microcode as KI10 paging,\r
                        used by earlier versions of TOPS10\r
        TOPS20          known in the KS10 microcode as KL10 paging,\r
                        used by later versions of TOPS10, and TOPS20\r
        ITS             used only by ITS\r
\r
   TOPS10 vs TOPS20 is selected by a bit in the EBR; ITS paging is\r
   "hardwired" (it required different microcode).\r
*/\r
\r
#include "pdp10_defs.h"\r
#include <setjmp.h>\r
\r
/* Page table (contains expanded pte's) */\r
\r
#define PTBL_ASIZE      PAG_N_VPN\r
#define PTBL_MEMSIZE    (1 << PTBL_ASIZE)               /* page table size */\r
#define PTBL_AMASK      (PTBL_MEMSIZE - 1)\r
#define PTBL_M          (1u << 31)                      /* must be sign bit */\r
#define PTBL_V          (1u << 30)\r
#define PTBL_MASK       (PAG_PPN | PTBL_M | PTBL_V)\r
\r
/* NXM processing */\r
\r
#define REF_V           0                               /* ref is virt */\r
#define REF_P           1                               /* ref is phys */\r
#define PF_OK           0                               /* pfail ok */\r
#define PF_TR           1                               /* pfail trap */\r
\r
extern d10 *M;\r
extern d10 acs[AC_NBLK * AC_NUM];\r
extern d10 *ac_cur, *ac_prv, *last_pa;\r
extern a10 epta, upta;\r
extern int32 flags;\r
extern d10 pager_word;\r
extern int32 apr_flg;\r
extern d10 ebr, ubr, hsb;\r
extern d10 spt, cst, cstm, pur;\r
extern a10 dbr1, dbr2, dbr3, dbr4;\r
extern d10 pcst, quant;\r
extern t_bool paging;\r
extern UNIT cpu_unit;\r
extern jmp_buf save_env;\r
extern int32 test_int (void);\r
extern int32 pi_eval (void);\r
\r
int32 eptbl[PTBL_MEMSIZE];                              /* exec page table */\r
int32 uptbl[PTBL_MEMSIZE];                              /* user page table */\r
int32 physptbl[PTBL_MEMSIZE];                           /* phys page table */\r
int32 *ptbl_cur, *ptbl_prv;\r
int32 save_ea;\r
\r
int32 ptbl_fill (a10 ea, int32 *ptbl, int32 mode);\r
t_stat pag_ex (t_value *vptr, t_addr addr, UNIT *uptr, int32 sw);\r
t_stat pag_dep (t_value val, t_addr addr, UNIT *uptr, int32 sw);\r
t_stat pag_reset (DEVICE *dptr);\r
void pag_nxm (a10 pa, int32 phys, int32 trap);\r
\r
/* Pager data structures\r
\r
   pag_dev      pager device descriptor\r
   pag_unit     pager units\r
   pager_reg    pager register list\r
*/\r
\r
UNIT pag_unit[] = {\r
    { UDATA (NULL, UNIT_FIX, PTBL_MEMSIZE) },\r
    { UDATA (NULL, UNIT_FIX, PTBL_MEMSIZE) }\r
    };\r
\r
REG pag_reg[] = {\r
    { ORDATA (PANIC_EA, save_ea, PASIZE), REG_HRO },\r
    { NULL }\r
    };\r
\r
DEVICE pag_dev = {\r
    "PAG", pag_unit, pag_reg, NULL,\r
    2, 8, PTBL_ASIZE, 1, 8, 32,\r
    &pag_ex, &pag_dep, &pag_reset,\r
    NULL, NULL, NULL,\r
    NULL, 0\r
    };\r
\r
/* Memory read and write routines\r
\r
   Read - read current or previous, read checking\r
   ReadM - read current or previous, write checking\r
   ReadE - read exec\r
   ReadP - read physical\r
   Write - write current or previous\r
   WriteE - write exec\r
   WriteP - write physical\r
   AccChk - test accessibility of virtual address\r
*/\r
\r
d10 Read (a10 ea, int32 prv)\r
{\r
int32 pa, vpn, xpte;\r
\r
if (ea < AC_NUM) return (prv? ac_prv[ea]: ac_cur[ea]);  /* AC request */\r
vpn = PAG_GETVPN (ea);                                  /* get page num */\r
xpte = prv? ptbl_prv[vpn]: ptbl_cur[vpn];               /* get exp pte */\r
if (xpte == 0) xpte = ptbl_fill (ea, prv? ptbl_prv: ptbl_cur, PTF_RD);\r
pa = PAG_XPTEPA (xpte, ea);                             /* calc phys addr */\r
if (MEM_ADDR_NXM (pa)) pag_nxm (pa, REF_V, PF_TR);      /* process nxm */\r
return M[pa];                                           /* return data */\r
}\r
\r
d10 ReadM (a10 ea, int32 prv)\r
{\r
int32 pa, vpn, xpte;\r
\r
if (ea < AC_NUM) return (prv? ac_prv[ea]: ac_cur[ea]);  /* AC request */\r
vpn = PAG_GETVPN (ea);                                  /* get page num */\r
xpte = prv? ptbl_prv[vpn]: ptbl_cur[vpn];               /* get exp pte */\r
if (xpte >= 0) xpte = ptbl_fill (ea, prv? ptbl_prv: ptbl_cur, PTF_WR);\r
pa = PAG_XPTEPA (xpte, ea);                             /* calc phys addr */\r
if (MEM_ADDR_NXM (pa)) pag_nxm (pa, REF_V, PF_TR);      /* process nxm */\r
return M[pa];                                           /* return data */\r
}\r
\r
d10 ReadE (a10 ea)\r
{\r
int32 pa, vpn, xpte;\r
\r
if (ea < AC_NUM) return AC(ea);                         /* AC? use current */\r
if (!PAGING) return M[ea];                              /* phys? no mapping */\r
vpn = PAG_GETVPN (ea);                                  /* get page num */\r
xpte = eptbl[vpn];                                      /* get exp pte, exec tbl */\r
if (xpte == 0) xpte = ptbl_fill (ea, eptbl, PTF_RD);\r
pa = PAG_XPTEPA (xpte, ea);                             /* calc phys addr */\r
if (MEM_ADDR_NXM (pa)) pag_nxm (pa, REF_V, PF_TR);      /* process nxm */\r
return M[pa];                                           /* return data */\r
}\r
\r
d10 ReadP (a10 ea)\r
{\r
if (ea < AC_NUM) return AC(ea);                         /* AC request */\r
if (MEM_ADDR_NXM (ea)) pag_nxm (ea, REF_P, PF_TR);      /* process nxm */\r
return M[ea];                                           /* return data */\r
}\r
\r
void Write (a10 ea, d10 val, int32 prv)\r
{\r
int32 pa, vpn, xpte;\r
\r
if (ea < AC_NUM) {                                      /* AC request */\r
    if (prv) ac_prv[ea] = val;                          /* write AC */\r
    else ac_cur[ea] = val;\r
    }\r
else {\r
    vpn = PAG_GETVPN (ea);                              /* get page num */\r
    xpte = prv? ptbl_prv[vpn]: ptbl_cur[vpn];           /* get exp pte */\r
    if (xpte >= 0) xpte = ptbl_fill (ea, prv? ptbl_prv: ptbl_cur, PTF_WR);\r
    pa = PAG_XPTEPA (xpte, ea);                         /* calc phys addr */\r
    if (MEM_ADDR_NXM (pa)) pag_nxm (pa, REF_V, PF_TR);  /* process nxm */\r
    else M[pa] = val;                                   /* write data */\r
    }\r
return;\r
}\r
\r
void WriteE (a10 ea, d10 val)\r
{\r
int32 pa, vpn, xpte;\r
\r
if (ea < AC_NUM) AC(ea) = val;                          /* AC? use current */\r
else if (!PAGING) M[ea] = val;                          /* phys? no mapping */\r
else {\r
    vpn = PAG_GETVPN (ea);                              /* get page num */\r
    xpte = eptbl[vpn];                                  /* get exp pte, exec tbl */\r
    if (xpte >= 0) xpte = ptbl_fill (ea, eptbl, PTF_WR);\r
    pa = PAG_XPTEPA (xpte, ea);                         /* calc phys addr */\r
    if (MEM_ADDR_NXM (pa)) pag_nxm (pa, REF_V, PF_TR);  /* process nxm */\r
    else M[pa] = val;                                   /* write data */\r
    }\r
return;\r
}\r
\r
void WriteP (a10 ea, d10 val)\r
{\r
if (ea < AC_NUM) AC(ea) = val;                          /* AC request */\r
else {\r
    if (MEM_ADDR_NXM (ea)) pag_nxm (ea, REF_P, PF_TR);  /* process nxm */\r
    M[ea] = val;                                        /* memory */\r
    }\r
return;\r
}\r
\r
t_bool AccViol (a10 ea, int32 prv, int32 mode)\r
{\r
int32 vpn, xpte;\r
\r
if (ea < AC_NUM) return FALSE;                          /* AC request */\r
vpn = PAG_GETVPN (ea);                                  /* get page num */\r
xpte = prv? ptbl_prv[vpn]: ptbl_cur[vpn];               /* get exp pte */\r
if ((xpte == 0) || ((mode & PTF_WR) && (xpte > 0)))     /* not accessible? */\r
    xpte = ptbl_fill (ea, prv? ptbl_prv: ptbl_cur, mode | PTF_MAP);\r
if (xpte) return FALSE;                                 /* accessible */\r
return TRUE;                                            /* not accessible */\r
}\r
\r
void pag_nxm (a10 pa, int32 phys, int32 trap)\r
{\r
apr_flg = apr_flg | APRF_NXM;                           /* set APR flag */\r
pi_eval ();                                             /* eval intr */\r
pager_word = PF_NXM | (phys? PF_NXMP: 0) |\r
    (TSTF (F_USR)? PF_USER: 0) | ((d10) pa);\r
if (PAGING && trap) ABORT (PAGE_FAIL);                  /* trap? */\r
return;\r
}\r
\r
/* Page table fill\r
\r
   This routine is called if the page table is invalid, or on a write\r
   reference if the page table is read only.  If the access is allowed\r
   it stores the pte in the page table entry and returns an expanded\r
   pte for use by the caller.  Otherwise, it generates a page fail.\r
\r
   Notes:\r
        - If called from the console, invalid references return a pte\r
          of 0, and the page table entry is not filled.\r
        - If called from MAP, invalid references return a pte of 0. The\r
          page fail word is properly set up.\r
*/\r
\r
#define PAGE_FAIL_TRAP  if (mode & (PTF_CON | PTF_MAP)) return 0; \\r
                        ABORT (PAGE_FAIL)\r
#define READPT(x,y)     if (MEM_ADDR_NXM (y)) { \\r
                            pag_nxm (y, REF_P, PF_OK); \\r
                            PAGE_FAIL_TRAP; \\r
                            } \\r
                        x = ReadP (y)\r
\r
int32 ptbl_fill (a10 ea, int32 *tbl, int32 mode)\r
{\r
\r
/* ITS paging is based on conventional page tables.  ITS divides each address\r
   space into a 128K high and low section, and uses different descriptor base\r
   pointers (dbr) for each.  ITS pages are twice the size of DEC standard;\r
   therefore, the fill routine fills two page table entries and returns the pte\r
   that maps the correct ITS half page.  This allows the DEC paging macros to\r
   be used in the normal path read-write routines.\r
\r
   ITS has no MAP instruction, therefore, physical NXM traps are ok.\r
*/\r
\r
if (Q_ITS) {                                            /* ITS paging */\r
    int32 acc, decvpn, pte, vpn, ptead, xpte;\r
    d10 ptewd;\r
\r
    vpn = ITS_GETVPN (ea);                              /* get ITS pagno */\r
    if (tbl == uptbl)\r
        ptead = ((ea & RSIGN)? dbr2: dbr1) + ((vpn >> 1) & 077);\r
    else ptead = ((ea & RSIGN)? dbr3: dbr4) + ((vpn >> 1) & 077);\r
    ptewd = ReadP (ptead);                              /* get PTE pair */\r
    pte = (int32) ((ptewd >> ((vpn & 1)? 0: 18)) & RMASK);\r
    acc = ITS_GETACC (pte);                             /* get access */\r
    pager_word = PF_VIRT | ea | ((tbl == uptbl)? PF_USER: 0) |\r
        ((mode & PTF_WR)? PF_ITS_WRITE: 0) | (acc << PF_ITS_V_ACC);\r
    if ((acc != ITS_ACC_NO) && (!(mode & PTF_WR) || (acc == ITS_ACC_RW))) { \r
        pte = pte & ~PTE_ITS_AGE;                       /* clear age */\r
        if (vpn & 1) WriteP (ptead, (ptewd & LMASK) | pte);\r
        else WriteP (ptead, (ptewd & RMASK) | (((d10) pte) << 18));\r
        xpte = ((pte & PTE_ITS_PPMASK) << ITS_V_PN) | PTBL_V |\r
            ((acc == ITS_ACC_RW)? PTBL_M: 0);\r
        decvpn = PAG_GETVPN (ea);                       /* get tlb idx */\r
        if (!(mode & PTF_CON)) {\r
            tbl[decvpn & ~1] = xpte;                    /* map lo ITS page */\r
            tbl[decvpn | 1] = xpte + PAG_SIZE;          /* map hi */\r
            }\r
        return (xpte + ((decvpn & 1)? PAG_SIZE: 0));\r
        }\r
    PAGE_FAIL_TRAP;\r
    }                                                   /* end ITS paging */\r
\r
/* TOPS-10 paging - checked against KS10 microcode\r
\r
   TOPS-10 paging is also based on conventional page tables.  The user page\r
   tables are arranged contiguously at the beginning of the user process table;\r
   however, the executive page tables are scattered through the executive and\r
   user process tables.\r
*/\r
\r
else if (!T20PAG) {                                     /* TOPS-10 paging */\r
    int32 pte, vpn, ptead, xpte;\r
    d10 ptewd;\r
\r
    vpn = PAG_GETVPN (ea);                              /* get virt page num */\r
    if (tbl == uptbl) ptead = upta + UPT_T10_UMAP + (vpn >> 1);\r
    else if (vpn < 0340) ptead = epta + EPT_T10_X000 + (vpn >> 1);\r
    else if (vpn < 0400) ptead = upta + UPT_T10_X340 + ((vpn - 0340) >> 1);\r
    else ptead = epta + EPT_T10_X400 + ((vpn - 0400) >> 1);\r
    READPT (ptewd, ptead);                              /* get PTE pair */\r
    pte = (int32) ((ptewd >> ((vpn & 1)? 0: 18)) & RMASK);\r
    pager_word = PF_VIRT | ea | ((tbl == uptbl)? PF_USER: 0) |\r
        ((mode & PTF_WR)? PF_WRITE: 0) |\r
        ((pte & PTE_T10_A)? PF_T10_A |\r
        ((pte & PTE_T10_S)? PF_T10_S: 0): 0);\r
    if (mode & PTF_MAP) pager_word = pager_word |       /* map? add to pf wd */\r
        ((pte & PTE_T10_W)? PF_T10_W: 0) |              /* W, S, C bits */\r
        ((pte & PTE_T10_S)? PF_T10_S: 0) |\r
        ((pte & PTE_T10_C)? PF_C: 0);\r
    if ((pte & PTE_T10_A) && (!(mode & PTF_WR) || (pte & PTE_T10_W))) {\r
        xpte = ((pte & PTE_PPMASK) << PAG_V_PN) |       /* calc exp pte */\r
            PTBL_V | ((pte & PTE_T10_W)? PTBL_M: 0);\r
        if (!(mode & PTF_CON)) tbl[vpn] = xpte;         /* set tbl if ~cons */\r
        return xpte;\r
        }\r
    PAGE_FAIL_TRAP;\r
    }                                                   /* end TOPS10 paging */\r
\r
/* TOPS-20 paging - checked against KS10 microcode\r
\r
   TOPS-20 paging has three phases:\r
\r
   1.   Starting at EPT/UPT + 540 + section number, chase section pointers to\r
        get the pointer to the section page table.  In the KS10, because there\r
        is only one section, the microcode caches the result of this evaluation.\r
        Also, the evaluation of indirect pointers is simplified, as the section\r
        table index is ignored.\r
\r
   2.   Starting with the page map pointer, chase page pointers to get the\r
        pointer to the page.  The KS10 allows the operating system to inhibit\r
        updating of the CST (base address = 0).\r
\r
   3.   Use the page pointer to get the CST entry.  If a write reference to\r
        a writeable page, set CST_M.  If CST_M is set, set M in page table.\r
*/\r
\r
else {                                                  /* TOPS-20 paging */\r
    int32 pmi, vpn, xpte;\r
    int32 flg, t;\r
    t_bool stop;\r
    a10 pa, csta;\r
    d10 ptr, cste;\r
    d10 acc = PTE_T20_W | PTE_T20_C;                    /* init access bits */\r
\r
    pager_word = PF_VIRT | ea | ((tbl == uptbl)? PF_USER: 0) |\r
        ((mode & PTF_WR)? PF_WRITE: 0);                 /* set page fail word */\r
\r
/* First phase - evaluate section pointers - returns a ptr to a page map\r
   As a single section machine, the KS10 short circuits this part of the\r
   process.  In particular, the indirect pointer calculation assumes that\r
   the section table index will be 0.  It adds the full pointer (not just\r
   the right half) to the SPT base.  If the section index is > 0, the\r
   result is a physical memory address > 256KW.  Depending on the size of\r
   memory, the SPT fetch may or may not generate a NXM page fail.  The\r
   KS10 then ignores the section table index in fetching the next pointer.\r
\r
   The KS10 KL10 memory management diagnostic (dskec.sav) tests for this\r
   behavior with a section index of 3.  However, this would be a legal\r
   physical address in a system with 1MW.  Accordingly, the simulator\r
   special cases non-zero section indices (which can't work in any case)\r
   to generate the right behavior for the diagnostic.\r
*/\r
\r
    vpn = PAG_GETVPN (ea);                              /* get virt page num */\r
    pa = (tbl == uptbl)? upta + UPT_T20_SCTN: epta + EPT_T20_SCTN;\r
    READPT (ptr, pa & PAMASK);                          /* get section 0 ptr */\r
    for (stop = FALSE, flg = 0; !stop; flg++) {         /* eval section ptrs */\r
        acc = acc & ptr;                                /* cascade acc bits */\r
        switch (T20_GETTYP (ptr)) {                     /* case on ptr type */\r
\r
        case T20_NOA:                                   /* no access */\r
        default:                                        /* undefined type */\r
            PAGE_FAIL_TRAP;                             /* page fail */\r
\r
        case T20_IMM:                                   /* immediate */\r
            stop = TRUE;                                /* exit */\r
            break;\r
\r
        case T20_SHR:                                   /* shared */\r
            pa = (int32) (spt + (ptr & RMASK));         /* get SPT idx */\r
            READPT (ptr, pa & PAMASK);                  /* get SPT entry */\r
            stop = TRUE;                                /* exit */\r
            break;\r
\r
        case T20_IND:                                   /* indirect */\r
            if (flg && (t = test_int ())) ABORT (t);\r
            pmi = T20_GETPMI (ptr);                     /* get sect tbl idx */\r
            pa = (int32) (spt + (ptr & RMASK));         /* get SPT idx */\r
            if (pmi) {                                  /* for dskec */\r
                pag_nxm ((pmi << 18) | pa, REF_P, PF_OK);\r
                PAGE_FAIL_TRAP;\r
                }\r
            READPT (ptr, pa & PAMASK);                  /* get SPT entry */\r
            if (ptr & PTE_T20_STM) { PAGE_FAIL_TRAP; }\r
            pa = PAG_PTEPA (ptr, pmi);                  /* index off page */\r
            READPT (ptr, pa & PAMASK);                  /* get pointer */\r
            break;                                      /* continue in loop */\r
            }                                           /* end case */\r
        }                                               /* end for */\r
\r
/* Second phase - found page map ptr, evaluate page pointers */\r
\r
    pa = PAG_PTEPA (ptr, vpn);                          /* get ptbl address */\r
    for (stop = FALSE, flg = 0; !stop; flg++) {         /* eval page ptrs */\r
        if (ptr & PTE_T20_STM) { PAGE_FAIL_TRAP; }      /* non-res? */\r
        if (cst) {                                      /* cst really there? */\r
            csta = (int32) ((cst + (ptr & PTE_PPMASK)) & PAMASK);\r
            READPT (cste, csta);                        /* get CST entry */\r
            if ((cste & CST_AGE) == 0) { PAGE_FAIL_TRAP; }\r
            cste = (cste & cstm) | pur;                 /* update entry */\r
            WriteP (csta, cste);                        /* rewrite */\r
            }\r
        READPT (ptr, pa & PAMASK);                      /* get pointer */\r
        acc = acc & ptr;                                /* cascade acc bits */\r
        switch (T20_GETTYP (ptr)) {                     /* case on ptr type */\r
\r
        case T20_NOA:                                   /* no access */\r
        default:                                        /* undefined type */\r
            PAGE_FAIL_TRAP;                             /* page fail */\r
\r
        case T20_IMM:                                   /* immediate */\r
            stop = TRUE;                                /* exit */\r
            break;\r
\r
        case T20_SHR:                                   /* shared */\r
            pa = (int32) (spt + (ptr & RMASK));         /* get SPT idx */\r
            READPT (ptr, pa & PAMASK);                  /* get SPT entry */\r
            stop = TRUE;                                /* exit */\r
            break;\r
\r
        case T20_IND:                                   /* indirect */\r
            if (flg && (t = test_int ())) ABORT (t);\r
            pmi = T20_GETPMI (ptr);                     /* get section index */\r
            pa = (int32) (spt + (ptr & RMASK));         /* get SPT idx */\r
            READPT (ptr, pa & PAMASK);                  /* get SPT entry */\r
            pa = PAG_PTEPA (ptr, pmi);                  /* index off page */\r
            break;                                      /* continue in loop */\r
            }                                           /* end case */\r
        }                                               /* end for */\r
\r
/* Last phase - have final page pointer, check modifiability */\r
\r
    if (ptr & PTE_T20_STM) { PAGE_FAIL_TRAP; }          /* non-resident? */\r
    if (cst) {                                          /* CST really there? */\r
        csta = (int32) ((cst + (ptr & PTE_PPMASK)) & PAMASK);\r
        READPT (cste, csta);                            /* get CST entry */\r
        if ((cste & CST_AGE) == 0) { PAGE_FAIL_TRAP; }\r
        cste = (cste & cstm) | pur;                     /* update entry */\r
        }\r
    else cste = 0;                                      /* no, entry = 0 */\r
    pager_word = pager_word | PF_T20_DN;                /* set eval done */\r
    xpte = ((int32) ((ptr & PTE_PPMASK) << PAG_V_PN)) | PTBL_V;\r
    if (mode & PTF_WR) {                                /* write? */\r
        if (acc & PTE_T20_W) {                          /* writable? */\r
            xpte = xpte | PTBL_M;                       /* set PTE M */\r
            cste = cste | CST_M;                        /* set CST M */\r
            }\r
        else { PAGE_FAIL_TRAP; }                        /* no, trap */\r
        }\r
    if (cst) WriteP (csta, cste);                       /* write CST entry */\r
    if (mode & PTF_MAP) pager_word = pager_word |       /* map? more in pf wd */\r
        ((xpte & PTBL_M)? PF_T20_M: 0) |                /* M, W, C bits */\r
        ((acc & PTE_T20_W)? PF_T20_W: 0) |\r
        ((acc & PTE_T20_C)? PF_C: 0);\r
    if (!(mode & PTF_CON)) tbl[vpn] = xpte;             /* set tbl if ~cons */\r
    return xpte;\r
    }                                                   /* end TOPS20 paging */\r
}\r
\r
/* Set up pointers for AC, memory, and process table access */\r
\r
void set_dyn_ptrs (void)\r
{\r
int32 t;\r
\r
if (PAGING) {\r
    ac_cur = &acs[UBR_GETCURAC (ubr) * AC_NUM];\r
    ac_prv = &acs[UBR_GETPRVAC (ubr) * AC_NUM];\r
    if (TSTF (F_USR)) ptbl_cur = ptbl_prv = &uptbl[0];\r
    else {\r
        ptbl_cur = &eptbl[0];\r
        ptbl_prv = TSTF (F_UIO)? &uptbl[0]: &eptbl[0];\r
        }\r
    }\r
else {\r
    ac_cur = ac_prv = &acs[0];\r
    ptbl_cur = ptbl_prv = &physptbl[0];\r
    }\r
t = EBR_GETEBR (ebr);\r
epta = t << PAG_V_PN;\r
if (Q_ITS) upta = (int32) ubr & PAMASK;\r
else {\r
    t = UBR_GETUBR (ubr);\r
    upta = t << PAG_V_PN;\r
    }\r
return;\r
}\r
\r
/* MAP instruction, TOPS-10 and TOPS-20 only\r
\r
   According to the KS-10 ucode, map with paging disabled sets\r
   "accessible, writeable, software", regardless of whether\r
   TOPS-10 or TOPS-20 paging is implemented\r
*/\r
\r
d10 map (a10 ea, int32 prv)\r
{\r
int32 xpte;\r
d10 val = (TSTF (F_USR)? PF_USER: 0);\r
\r
if (!PAGING) return (val | PF_T10_A | PF_T10_W | PF_T10_S | ea);\r
xpte = ptbl_fill (ea, prv? ptbl_prv: ptbl_cur, PTF_MAP); /* get exp pte */\r
if (xpte) val = (pager_word & ~PAMASK) | PAG_XPTEPA (xpte, ea);\r
else {\r
    if (pager_word & PF_HARD) val = pager_word;         /* hard error */\r
    else val = val | PF_VIRT | ea;                      /* inaccessible */\r
    }\r
return val;\r
}\r
\r
/* Mapping routine for console */\r
\r
a10 conmap (a10 ea, int32 mode, int32 sw)\r
{\r
int32 xpte, *tbl;\r
\r
if (!PAGING) return ea;\r
set_dyn_ptrs ();                                        /* in case changed */\r
if (sw & SWMASK ('E')) tbl = eptbl;\r
else if (sw & SWMASK ('U')) tbl = uptbl;\r
else tbl = ptbl_cur;\r
xpte = ptbl_fill (ea, tbl, mode);\r
if (xpte) return PAG_XPTEPA (xpte, ea);\r
else return MAXMEMSIZE;\r
}\r
\r
/* Common pager instructions */\r
\r
t_bool clrpt (a10 ea, int32 prv)\r
{\r
int32 vpn = PAG_GETVPN (ea);                            /* get page num */\r
\r
if (Q_ITS) {                                            /* ITS? */\r
    uptbl[vpn & ~1] = 0;                                /* clear double size */\r
    uptbl[vpn | 1] = 0;                                 /* entries in */\r
    eptbl[vpn & ~1] = 0;                                /* both page tables */\r
    eptbl[vpn | 1] = 0;\r
    }\r
else {\r
    uptbl[vpn] = 0;                                     /* clear entries in */\r
    eptbl[vpn] = 0;                                     /* both page tables */\r
    }\r
return FALSE;\r
} \r
\r
t_bool wrebr (a10 ea, int32 prv)\r
{\r
ebr = ea & EBR_MASK;                                    /* store EBR */\r
pag_reset (&pag_dev);                                   /* clear page tables */\r
set_dyn_ptrs ();                                        /* set dynamic ptrs */\r
return FALSE;\r
}\r
\r
t_bool rdebr (a10 ea, int32 prv)\r
{\r
Write (ea, (ebr & EBR_MASK), prv);\r
return FALSE;\r
}\r
\r
t_bool wrubr (a10 ea, int32 prv)\r
{\r
d10 val = Read (ea, prv);\r
d10 ubr_mask = (Q_ITS)? PAMASK: UBR_UBRMASK;            /* ITS: ubr is wd addr */\r
\r
if (val & UBR_SETACB) ubr = ubr & ~UBR_ACBMASK;         /* set AC's? */\r
else val = val & ~UBR_ACBMASK;                          /* no, keep old val */\r
if (val & UBR_SETUBR) {                                 /* set UBR? */\r
    ubr = ubr & ~ubr_mask;\r
    pag_reset (&pag_dev);                               /* yes, clr pg tbls */\r
    }\r
else val = val & ~ubr_mask;                             /* no, keep old val */\r
ubr = (ubr | val) & (UBR_ACBMASK | ubr_mask);\r
set_dyn_ptrs ();\r
return FALSE;\r
}\r
\r
t_bool rdubr (a10 ea, int32 prv)\r
{\r
ubr = ubr & (UBR_ACBMASK | (Q_ITS? PAMASK: UBR_UBRMASK));\r
Write (ea, UBRWORD, prv);\r
return FALSE;\r
}\r
\r
t_bool wrhsb (a10 ea, int32 prv)\r
{\r
hsb = Read (ea, prv) & PAMASK;\r
return FALSE;\r
}\r
\r
t_bool rdhsb (a10 ea, int32 prv)\r
{\r
Write (ea, hsb, prv);\r
return FALSE;\r
}\r
\r
/* TOPS20 pager instructions */\r
\r
t_bool wrspb (a10 ea, int32 prv)\r
{\r
spt = Read (ea, prv);\r
return FALSE;\r
}\r
\r
t_bool rdspb (a10 ea, int32 prv)\r
{\r
Write (ea, spt, prv);\r
return FALSE;\r
}\r
\r
t_bool wrcsb (a10 ea, int32 prv)\r
{\r
cst = Read (ea, prv);\r
return FALSE;\r
}\r
\r
t_bool rdcsb (a10 ea, int32 prv)\r
{\r
Write (ea, cst, prv);\r
return FALSE;\r
}\r
\r
t_bool wrpur (a10 ea, int32 prv)\r
{\r
pur = Read (ea, prv);\r
return FALSE;\r
}\r
\r
t_bool rdpur (a10 ea, int32 prv)\r
{\r
Write (ea, pur, prv);\r
return FALSE;\r
}\r
\r
t_bool wrcstm (a10 ea, int32 prv)\r
{\r
cstm = Read (ea, prv);\r
if ((cpu_unit.flags & UNIT_T20) && (ea == 040127))\r
    cstm = 0770000000000;\r
return FALSE;\r
}\r
\r
t_bool rdcstm (a10 ea, int32 prv)\r
{\r
Write (ea, cstm, prv);\r
return FALSE;\r
}\r
\r
/* ITS pager instructions\r
   The KS10 does not implement the JPC option.\r
*/\r
\r
t_bool clrcsh (a10 ea, int32 prv)\r
{\r
return FALSE;\r
}\r
\r
t_bool ldbr1 (a10 ea, int32 prv)\r
{\r
dbr1 = ea;\r
pag_reset (&pag_dev);\r
return FALSE;\r
}\r
\r
t_bool sdbr1 (a10 ea, int32 prv)\r
{\r
Write (ea, dbr1, prv);\r
return FALSE;\r
}\r
\r
t_bool ldbr2 (a10 ea, int32 prv)\r
{\r
dbr2 = ea;\r
pag_reset (&pag_dev);\r
return FALSE;\r
}\r
\r
t_bool sdbr2 (a10 ea, int32 prv)\r
{\r
Write (ea, dbr2, prv);\r
return FALSE;\r
}\r
\r
t_bool ldbr3 (a10 ea, int32 prv)\r
{\r
dbr3 = ea;\r
pag_reset (&pag_dev);\r
return FALSE;\r
}\r
\r
t_bool sdbr3 (a10 ea, int32 prv)\r
{\r
Write (ea, dbr3, prv);\r
return FALSE;\r
}\r
\r
t_bool ldbr4 (a10 ea, int32 prv)\r
{\r
dbr4 = ea;\r
pag_reset (&pag_dev);\r
return FALSE;\r
}\r
\r
t_bool sdbr4 (a10 ea, int32 prv)\r
{\r
Write (ea, dbr4, prv);\r
return FALSE;\r
}\r
\r
t_bool wrpcst (a10 ea, int32 prv)\r
{\r
pcst = Read (ea, prv);\r
return FALSE;\r
}\r
\r
t_bool rdpcst (a10 ea, int32 prv)\r
{\r
Write (ea, pcst, prv);\r
return FALSE;\r
}\r
\r
t_bool lpmr (a10 ea, int32 prv)\r
{\r
d10 val;\r
\r
val = Read (ADDA (ea, 2), prv);\r
dbr1 = (a10) (Read (ea, prv) & AMASK);\r
dbr2 = (a10) (Read (ADDA (ea, 1), prv) & AMASK);\r
quant = val;\r
pag_reset (&pag_dev);\r
return FALSE;\r
}\r
\r
t_bool spm (a10 ea, int32 prv)\r
{\r
\r
ReadM (ADDA (ea, 2), prv);\r
Write (ea, dbr1, prv);\r
Write (ADDA (ea, 1), dbr2, prv);\r
Write (ADDA (ea, 2), quant, prv);\r
return FALSE;\r
}\r
\r
/* Simulator interface routines */\r
\r
t_stat pag_ex (t_value *vptr, t_addr addr, UNIT *uptr, int32 sw)\r
{\r
int32 tbln = uptr - pag_unit;\r
\r
if (addr >= PTBL_MEMSIZE) return SCPE_NXM;\r
*vptr = tbln? uptbl[addr]: eptbl[addr];;\r
return SCPE_OK;\r
}\r
\r
t_stat pag_dep (t_value val, t_addr addr, UNIT *uptr, int32 sw)\r
{\r
int32 tbln = uptr - pag_unit;\r
\r
if (addr >= PTBL_MEMSIZE) return SCPE_NXM;\r
if (tbln) uptbl[addr] = (int32) val & PTBL_MASK;\r
else eptbl[addr] = (int32) val & PTBL_MASK;\r
return SCPE_OK;\r
}\r
\r
t_stat pag_reset (DEVICE *dptr)\r
{\r
int32 i;\r
\r
for (i = 0; i < PTBL_MEMSIZE; i++) {\r
    eptbl[i] = uptbl[i] = 0;\r
    physptbl[i] = (i << PAG_V_PN) + PTBL_M + PTBL_V;\r
    }\r
return SCPE_OK;\r
}\r