do_load.c 3.3 KB

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