util/int/do_load.c

   1 /*
   2  * Sources of the "LOAD" group instructions
   3  */
   4
   5 /* $Id: do_load.c,v 2.5 1994/06/24 10:46:33 ceriel Exp $ */
   6
   7 #include        <em_abs.h>
   8 #include        "global.h"
   9 #include        "log.h"
  10 #include        "mem.h"
  11 #include        "trap.h"
  12 #include        "text.h"
  13 #include        "fra.h"
  14 #include        "rsb.h"
  15 #include        "warn.h"
  16
  17 PRIVATE ptr lexback_LB();
  18
  19 DoLOC(l)
  20         register long l;
  21 {
  22         /* LOC c: Load constant (i.e. push one word onto the stack) */
  23
  24         LOG(("@L6 DoLOC(%ld)", l));
  25         spoilFRA();
  26         wpush(arg_c(l));
  27 }
  28
  29 DoLDC(l)
  30         register long l;
  31 {
  32         /* LDC d: Load double constant ( push two words ) */
  33
  34         LOG(("@L6 DoLDC(%ld)", l));
  35         spoilFRA();
  36         l = arg_d(l);
  37         npush(l, dwsize);
  38 }
  39
  40 DoLOL(l)
  41         register long l;
  42 {
  43         /* LOL l: Load word at l-th local (l<0) or parameter (l>=0) */
  44
  45         LOG(("@L6 DoLOL(%ld)", l));
  46         spoilFRA();
  47         l = arg_l(l);
  48         pushw_st(loc_addr(l));
  49 }
  50
  51 DoLOE(arg)
  52         register long arg;
  53 {
  54         /* LOE g: Load external word g */
  55         register ptr p = i2p(arg);
  56
  57         LOG(("@L6 DoLOE(%lu)", p));
  58         spoilFRA();
  59         pushw_m(arg_g(p));
  60 }
  61
  62 DoLIL(l)
  63         register long l;
  64 {
  65         /* LIL l: Load word pointed to by l-th local or parameter */
  66
  67         LOG(("@L6 DoLIL(%ld)", l));
  68         spoilFRA();
  69         l = arg_l(l);
  70         pushw_m(st_lddp(loc_addr(l)));
  71 }
  72
  73 DoLOF(l)
  74         register long l;
  75 {
  76         /* LOF f: Load offsetted (top of stack + f yield address) */
  77         register ptr p = dppop();
  78
  79         LOG(("@L6 DoLOF(%ld)", l));
  80         spoilFRA();
  81         pushw_m(p + arg_f(l));
  82 }
  83
  84 DoLAL(l)
  85         register long l;
  86 {
  87         /* LAL l: Load address of local or parameter */
  88
  89         LOG(("@L6 DoLAL(%ld)", l));
  90         spoilFRA();
  91         l = arg_l(l);
  92         dppush(loc_addr(l));
  93 }
  94
  95 DoLAE(arg)
  96         register unsigned long arg;
  97 {
  98         /* LAE g: Load address of external */
  99         register ptr p = i2p(arg);
 100
 101         LOG(("@L6 DoLAE(%lu)", p));
 102         spoilFRA();
 103         dppush(arg_lae(p));
 104 }
 105
 106 DoLXL(l)
 107         register unsigned long l;
 108 {
 109         /* LXL n: Load lexical (address of LB n static levels back) */
 110         register ptr p;
 111
 112         LOG(("@L6 DoLXL(%lu)", l));
 113         spoilFRA();
 114         l = arg_n(l);
 115         p = lexback_LB(l);
 116         dppush(p);
 117 }
 118
 119 DoLXA(l)
 120         register unsigned long l;
 121 {
 122         /* LXA n: Load lexical (address of AB n static levels back) */
 123         register ptr p;
 124
 125         LOG(("@L6 DoLXA(%lu)", l));
 126         spoilFRA();
 127         l = arg_n(l);
 128         p = lexback_LB(l);
 129         dppush(p + rsbsize);
 130 }
 131
 132 DoLOI(l)
 133         register size l;
 134 {
 135         /* LOI o: Load indirect o bytes (address is popped from the stack) */
 136         register ptr p = dppop();
 137
 138         LOG(("@L6 DoLOI(%ld)", l));
 139         spoilFRA();
 140         l = arg_o(l);
 141         push_m(p, l);
 142 }
 143
 144 DoLOS(l)
 145         register size l;
 146 {
 147         /* LOS w: Load indirect, w-byte integer on top of stack gives object size */
 148         register ptr p;
 149
 150         LOG(("@L6 DoLOS(%ld)", l));
 151         spoilFRA();
 152         l = arg_wi(l);
 153         l = upop(l);
 154         p = dppop();
 155         push_m(p, arg_o(l));
 156 }
 157
 158 DoLDL(l)
 159         register long l;
 160 {
 161         /* LDL l: Load double local or parameter (two consecutive words are stacked) */
 162
 163         LOG(("@L6 DoLDL(%ld)", l));
 164         spoilFRA();
 165         l = arg_l(l);
 166         push_st(loc_addr(l), dwsize);
 167 }
 168
 169 DoLDE(arg)
 170         register long arg;
 171 {
 172         /* LDE g: Load double external (two consecutive externals are stacked) */
 173         register ptr p = i2p(arg);
 174
 175         LOG(("@L6 DoLDE(%lu)", p));
 176         spoilFRA();
 177         push_m(arg_g(p), dwsize);
 178 }
 179
 180 DoLDF(l)
 181         register long l;
 182 {
 183         /* LDF f: Load double offsetted (top of stack + f yield address) */
 184         register ptr p = dppop();
 185
 186         LOG(("@L6 DoLDF(%ld)", l));
 187         spoilFRA();
 188         push_m(p + arg_f(l), dwsize);
 189 }
 190
 191 DoLPI(pi)
 192         register long pi;
 193 {
 194         /* LPI p: Load procedure identifier */
 195
 196         LOG(("@L6 DoLPI(%ld)", pi));
 197         spoilFRA();
 198         npush(arg_p(pi), psize);
 199 }
 200
 201 PRIVATE ptr lexback_LB(n)
 202         unsigned long n;
 203 {
 204         /* LB n static levels back */
 205         register ptr lb = LB;
 206
 207         while (n != 0) {
 208                 lb = st_lddp(lb + rsbsize);
 209                 n--;
 210         }
 211         return lb;
 212 }
 213