home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / unix / volume25 / trash / part02 / i_l.c < prev    next >
Encoding:
C/C++ Source or Header  |  1992-03-22  |  8.3 KB  |  535 lines
  1. #include    <stdio.h>
  2. #include    "register.h"
  3. #include    "symtab.h"
  4. #include    "diblock.h"
  5. #include    "instrn.h"
  6. #include    "process.h"
  7. #include    "wcache.h"
  8. #include    "talloc.h"
  9. #include    "nels.h"
  10.  
  11. #define    char_to_signed_long(C)    (long)(((C) & 0x80) ? ((C) | 0xFFFFFF80) : (C))
  12.  
  13. #define    quiet_procmget_word(dipc,offset,ip,n,S,T) \
  14. { \
  15.     int        i; \
  16.     unsigned long    *wp; \
  17.  \
  18.     if ((i = offset - P.p_data_region_min) >= 0) \
  19.     { \
  20.         if (n == sizeof(int)) \
  21.         { \
  22.             if (offset <= P.p_data_region_wlimit) \
  23.             { \
  24.                 wp = (unsigned long *)&P.p_data_region[i]; \
  25.                 *ip = *wp; \
  26.                 S; \
  27.                 T; \
  28.                 return dipc; \
  29.             } \
  30.         } \
  31.         else if (n == sizeof(short)) \
  32.         { \
  33.             if (offset <= P.p_data_region_limit + 1 - n) \
  34.             { \
  35.                 *ip = *(unsigned short *)&P.p_data_region[i]; \
  36.                 S; \
  37.                 T; \
  38.                 return dipc; \
  39.             } \
  40.         } \
  41.         else \
  42.         { \
  43.             if (offset <= P.p_data_region_limit) \
  44.             { \
  45.                 *ip = *(unsigned char *)&P.p_data_region[i]; \
  46.                 S; \
  47.                 T; \
  48.                 return dipc; \
  49.             } \
  50.         } \
  51.  \
  52.         if (offset <= STACK_WMAX) \
  53.         { \
  54.             if ((i = offset - P.p_stack_region_min) < 0) \
  55.             { \
  56.                 (void)proc_grow_stack(dipc, offset); \
  57.  \
  58.                 i = offset - P.p_stack_region_min; \
  59.             } \
  60.  \
  61.             if (n == sizeof(int)) \
  62.             { \
  63.                 wp = (unsigned long *)&P.p_stack_region[i]; \
  64.                 *ip = *wp; \
  65.             } \
  66.             else if (n == sizeof(short)) \
  67.                 *ip = *(unsigned short *)&P.p_stack_region[i]; \
  68.             else \
  69.                 *ip = *(unsigned char *)&P.p_stack_region[i]; \
  70.  \
  71.             S; \
  72.             T; \
  73.             return dipc; \
  74.         } \
  75.     } \
  76.  \
  77.     (void)quiet_procmget(dipc, offset, (unsigned char *)ip, n); \
  78.     S; \
  79.     return dipc; \
  80. }
  81.  
  82. static
  83. dinstrn    *
  84. c_lb0(dipc)
  85. dinstrn    *dipc;
  86. {
  87.     unsigned long    addr;
  88.     unsigned char    c;
  89.     unsigned long    *lp;
  90.  
  91.     addr = *dipc->di_1;
  92.     lp = dipc->di_0;
  93.  
  94.     quiet_procmget_word(dipc, addr, &c, sizeof(c), *lp = (unsigned long)char_to_signed_long(c), ;);
  95. }
  96.  
  97. static
  98. dinstrn    *
  99. c_lb(dipc)
  100. dinstrn    *dipc;
  101. {
  102.     unsigned long    addr;
  103.     unsigned char    c;
  104.     unsigned long    *lp;
  105.  
  106.     addr = *dipc->di_1 + (long)dipc->di_2;
  107.     lp = dipc->di_0;
  108.  
  109.     quiet_procmget_word(dipc, addr, &c, sizeof(c), *lp = (unsigned long)char_to_signed_long(c), ;);
  110. }
  111.  
  112. dinstrn    *
  113. i_lb(dipc, base, rt, offset)
  114. dinstrn    *dipc;
  115. int    base;
  116. int    rt;
  117. short    offset;
  118. {
  119.     unsigned long    b;
  120.     unsigned char    c;
  121.  
  122.     if (compile_ok)
  123.     {
  124.         if (rt == R_0)
  125.             dipc->di_handler = c_noop;
  126.         else
  127.         {
  128.             if (offset == (short)0)
  129.                 dipc->di_handler = c_lb0;
  130.             else
  131.                 dipc->di_handler = c_lb;
  132.             dipc->di_0 = &P.p_state[rt];
  133.             dipc->di_1 = &P.p_state[base];
  134.             dipc->di_2 = (unsigned long *)(long)offset;
  135.         }
  136.  
  137.         return (*dipc->di_handler)(dipc);
  138.     }
  139.  
  140.     procsget(base, b);
  141.  
  142.     if (procmget(dipc, b + (long)offset, (char *)&c, sizeof(c)) != -1)
  143.         procsput(rt, char_to_signed_long(c));
  144.  
  145.     return dipc;
  146. }
  147.  
  148. static
  149. dinstrn    *
  150. c_lbu(dipc)
  151. dinstrn    *dipc;
  152. {
  153.     unsigned long    addr;
  154.     unsigned char    c;
  155.     unsigned long    *lp;
  156.  
  157.     addr = *dipc->di_1 + (long)dipc->di_2;
  158.     lp = dipc->di_0;
  159.  
  160.     quiet_procmget_word(dipc, addr, &c, sizeof(c), *lp = (unsigned long)c, ;);
  161. }
  162.  
  163. dinstrn    *
  164. i_lbu(dipc, base, rt, offset)
  165. dinstrn    *dipc;
  166. int    base;
  167. int    rt;
  168. short    offset;
  169. {
  170.     unsigned long    b;
  171.     unsigned char    c;
  172.  
  173.     if (compile_ok)
  174.     {
  175.         if (rt == R_0)
  176.             dipc->di_handler = c_noop;
  177.         else
  178.         {
  179.             dipc->di_handler = c_lbu;
  180.             dipc->di_0 = &P.p_state[rt];
  181.             dipc->di_1 = &P.p_state[base];
  182.             dipc->di_2 = (unsigned long *)(long)offset;
  183.         }
  184.  
  185.         return (*dipc->di_handler)(dipc);
  186.     }
  187.  
  188.     procsget(base, b);
  189.  
  190.     if (procmget(dipc, b + (long)offset, (char *)&c, sizeof(c)) != -1)
  191.         procsput(rt, (unsigned long)c);
  192.  
  193.     return dipc;
  194. }
  195.  
  196. static
  197. dinstrn    *
  198. c_lh(dipc)
  199. dinstrn    *dipc;
  200. {
  201.     unsigned long    addr;
  202.     unsigned long    *lp;
  203.     short        m;
  204.  
  205.     addr = *dipc->di_1 + (long)dipc->di_2;
  206.     lp = dipc->di_0;
  207.  
  208.     check_halfword_align(dipc, addr);
  209.  
  210.     quiet_procmget_word(dipc, addr, &m, sizeof(m), *lp = (unsigned long)(long)m, ;);
  211. }
  212.  
  213. dinstrn    *
  214. i_lh(dipc, base, rt, offset)
  215. dinstrn    *dipc;
  216. int    base;
  217. int    rt;
  218. short    offset;
  219. {
  220.     unsigned long    b;
  221.     unsigned long    addr;
  222.     short        m;
  223.  
  224.     if (compile_ok)
  225.     {
  226.         if (rt == R_0)
  227.             dipc->di_handler = c_noop;
  228.         else
  229.         {
  230.             dipc->di_handler = c_lh;
  231.             dipc->di_0 = &P.p_state[rt];
  232.             dipc->di_1 = &P.p_state[base];
  233.             dipc->di_2 = (unsigned long *)(long)offset;
  234.         }
  235.  
  236.         return (*dipc->di_handler)(dipc);
  237.     }
  238.  
  239.     procsget(base, b);
  240.  
  241.     addr = b + (long)offset;
  242.  
  243.     check_halfword_align(dipc, addr);
  244.  
  245.     if (procmget(dipc, addr, (char *)&m, sizeof(m)) != -1)
  246.         procsput(rt, (long)m);
  247.  
  248.     return dipc;
  249. }
  250.  
  251. dinstrn    *
  252. i_lhu(dipc, base, rt, offset)
  253. dinstrn    *dipc;
  254. int    base;
  255. int    rt;
  256. short    offset;
  257. {
  258.     unsigned long    b;
  259.     unsigned long    addr;
  260.     unsigned short    m;
  261.  
  262.     procsget(base, b);
  263.  
  264.     addr = b + (long)offset;
  265.  
  266.     check_halfword_align(dipc, addr);
  267.  
  268.     if (procmget(dipc, addr, (char *)&m, sizeof(m)) != -1)
  269.         procsput(rt, (unsigned long)m);
  270.  
  271.     return dipc;
  272. }
  273.  
  274. static
  275. dinstrn    *
  276. c_lui(dipc)
  277. dinstrn    *dipc;
  278. {
  279.     *dipc->di_0 = (unsigned long)dipc->di_1;
  280.  
  281.     return dipc;
  282. }
  283.  
  284. dinstrn    *
  285. i_lui(dipc, rs, rt, immediate)
  286. dinstrn    *dipc;
  287. int    rs;
  288. int    rt;
  289. short    immediate;
  290. {
  291.     unsigned long    t;
  292.  
  293.     if (compile_ok)
  294.     {
  295.         if (rt == R_0)
  296.             dipc->di_handler = c_noop;
  297.         else
  298.         {
  299.             dipc->di_handler = c_lui;
  300.             dipc->di_0 = &P.p_state[rt];
  301.             dipc->di_1 = (unsigned long *)((immediate << 16) & 0xFFFF0000);
  302.         }
  303.  
  304.         return (*dipc->di_handler)(dipc);
  305.     }
  306.  
  307.     t = (immediate << 16) & 0xFFFF0000;
  308.  
  309.     procsput(rt, t);
  310.  
  311.     return dipc;
  312. }
  313.  
  314. static
  315. dinstrn    *
  316. c_lw0(dipc)
  317. dinstrn    *dipc;
  318. {
  319.     unsigned long    addr;
  320.     unsigned long    *lp;
  321.     cent        *cap;
  322.  
  323.     addr = *dipc->di_1;
  324.     lp = dipc->di_0;
  325.  
  326.     if ((cap = &wcache[addr % CACHEZ])->c_addr == addr)
  327.     {
  328.         *lp = *cap->c_ptr;
  329.         return dipc;
  330.     }
  331.  
  332.     check_word_align(dipc, addr);
  333.  
  334.     quiet_procmget_word(dipc, addr, lp, sizeof(*lp), ;, cap->c_ptr = wp; cap->c_addr = addr);
  335. }
  336.  
  337. static
  338. dinstrn    *
  339. c_lw4(dipc)
  340. dinstrn    *dipc;
  341. {
  342.     unsigned long    addr;
  343.     unsigned long    *lp;
  344.     cent        *cap;
  345.  
  346.     addr = *dipc->di_1 + 4;
  347.     lp = dipc->di_0;
  348.  
  349.     if ((cap = &wcache[addr % CACHEZ])->c_addr == addr)
  350.     {
  351.         *lp = *cap->c_ptr;
  352.         return dipc;
  353.     }
  354.  
  355.     check_word_align(dipc, addr);
  356.  
  357.     quiet_procmget_word(dipc, addr, lp, sizeof(*lp), ;, cap->c_ptr = wp; cap->c_addr = addr);
  358. }
  359.  
  360. static
  361. dinstrn    *
  362. c_lw8(dipc)
  363. dinstrn    *dipc;
  364. {
  365.     unsigned long    addr;
  366.     unsigned long    *lp;
  367.     cent        *cap;
  368.  
  369.     addr = *dipc->di_1 + 8;
  370.     lp = dipc->di_0;
  371.  
  372.     if ((cap = &wcache[addr % CACHEZ])->c_addr == addr)
  373.     {
  374.         *lp = *cap->c_ptr;
  375.         return dipc;
  376.     }
  377.  
  378.     check_word_align(dipc, addr);
  379.  
  380.     quiet_procmget_word(dipc, addr, lp, sizeof(*lp), ;, cap->c_ptr = wp; cap->c_addr = addr);
  381. }
  382.  
  383. static
  384. dinstrn    *
  385. c_lw(dipc)
  386. dinstrn    *dipc;
  387. {
  388.     unsigned long    addr;
  389.     unsigned long    *lp;
  390.     cent        *cap;
  391.  
  392.     addr = *dipc->di_1 + (long)dipc->di_2;
  393.     lp = dipc->di_0;
  394.  
  395.     if ((cap = &wcache[addr % CACHEZ])->c_addr == addr)
  396.     {
  397.         *lp = *cap->c_ptr;
  398.         return dipc;
  399.     }
  400.  
  401.     check_word_align(dipc, addr);
  402.  
  403.     quiet_procmget_word(dipc, addr, lp, sizeof(*lp), ;, cap->c_ptr = wp; cap->c_addr = addr);
  404. }
  405.  
  406. dinstrn    *
  407. i_lw(dipc, base, rt, offset)
  408. dinstrn    *dipc;
  409. int    base;
  410. int    rt;
  411. short    offset;
  412. {
  413.     unsigned long    b;
  414.     unsigned long    addr;
  415.     unsigned long    t;
  416.  
  417.     if (compile_ok)
  418.     {
  419.         if (rt == R_0)
  420.             dipc->di_handler = c_noop;
  421.         else
  422.         {
  423.             switch (offset)
  424.             {
  425.             case 0:
  426.                 dipc->di_handler = c_lw0;
  427.                 break;
  428.  
  429.             case 4:
  430.                 dipc->di_handler = c_lw4;
  431.                 break;
  432.  
  433.             case 8:
  434.                 dipc->di_handler = c_lw8;
  435.                 break;
  436.  
  437.             default:
  438.                 dipc->di_handler = c_lw;
  439.                 break;
  440.             }
  441.             dipc->di_0 = &P.p_state[rt];
  442.             dipc->di_1 = &P.p_state[base];
  443.             dipc->di_2 = (unsigned long *)(long)offset;
  444.         }
  445.  
  446.         return (*dipc->di_handler)(dipc);
  447.     }
  448.  
  449.     procsget(base, b);
  450.  
  451.     addr = b + (long)offset;
  452.  
  453.     check_word_align(dipc, addr);
  454.  
  455.     if (procmget(dipc, addr, (char *)&t, sizeof(t)) != -1)
  456.         procsput(rt, t);
  457.  
  458.     return dipc;
  459. }
  460.  
  461. dinstrn    *
  462. i_lwc1(dipc, base, rt, offset)
  463. dinstrn    *dipc;
  464. int    base;
  465. int    rt;
  466. short    offset;
  467. {
  468.     unsigned long    b;
  469.     unsigned long    addr;
  470.     unsigned long    t;
  471.  
  472.     procsget(base, b);
  473.  
  474.     addr = b + (long)offset;
  475.  
  476.     check_word_align(dipc, addr);
  477.  
  478.     if (procmget(dipc, addr, (char *)&t, sizeof(t)) != -1)
  479.         procsput(CP1G(rt), t);
  480.  
  481.     return dipc;
  482. }
  483.  
  484. dinstrn    *
  485. i_lwl(dipc, base, rt, offset)
  486. dinstrn    *dipc;
  487. int    base;
  488. int    rt;
  489. short    offset;
  490. {
  491.     unsigned long    b;
  492.     unsigned long    addr;
  493.     unsigned long    t;
  494.     int        length;
  495.  
  496.     procsget(base, b);
  497.  
  498.     addr = b + offset;
  499.  
  500.     procsget(rt, t);
  501.  
  502.     length = sizeof(t) - (addr - (addr & ~0x3));
  503.  
  504.     if (procmget(dipc, addr, (unsigned char *)&t, length) != -1)
  505.         procsput(rt, t);
  506.  
  507.     return dipc;
  508. }
  509.  
  510. dinstrn    *
  511. i_lwr(dipc, base, rt, offset)
  512. dinstrn    *dipc;
  513. int    base;
  514. int    rt;
  515. short    offset;
  516. {
  517.     unsigned long    b;
  518.     unsigned long    addr;
  519.     unsigned long    t;
  520.     int        length;
  521.  
  522.     procsget(base, b);
  523.  
  524.     addr = b + offset;
  525.  
  526.     procsget(rt, t);
  527.  
  528.     length = (addr - (addr & ~0x3)) + 1;
  529.  
  530.     if (procmget(dipc, addr & ~0x3, ((unsigned char *)&t) + (sizeof(t) - length), length) != -1)
  531.         procsput(rt, t);
  532.  
  533.     return dipc;
  534. }
  535.