mach5.c 7.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457
  1. /* $Header$ */
  2. /*
  3. * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  4. * See the copyright notice in the ACK home directory, in the file "Copyright".
  5. */
  6. /* @(#)mach5.c 1.16 */
  7. /*
  8. * Motorola 68000/68010 auxiliary functions
  9. */
  10. ea_1(sz, bits)
  11. {
  12. register flag;
  13. if (mrg_1 > 074)
  14. serror("no specials");
  15. if ((flag = eamode[mrg_1>>3]) == 0)
  16. if ((flag = eamode[010 + (mrg_1&07)]) == 0)
  17. flag = eamode[015 + (sz>>6)];
  18. if ((mrg_1 & 070) == 010)
  19. checksize(sz, 2|4);
  20. bits &= ~flag;
  21. if (bits)
  22. serror("bad addressing categorie");
  23. if (flag & FITW)
  24. if (
  25. ! fitw(exp_1.val)
  26. &&
  27. (mrg_1 != 074 || ! fit16(exp_1.val))
  28. )
  29. nofit();
  30. if (flag & FITB) {
  31. if (
  32. ! fitb(exp_1.val)
  33. &&
  34. (mrg_1 != 074 || ! fit8(exp_1.val))
  35. )
  36. nofit();
  37. if (mrg_1 == 074)
  38. exp_1.val &= 0xFF;
  39. }
  40. #ifdef RELOCATION
  41. RELOMOVE(relonami, rel_1);
  42. if (flag & ~0xFF)
  43. newrelo(exp_1.typ, (flag>>8) | RELBR | RELWR);
  44. #endif
  45. if (flag & PUTL)
  46. emit4(exp_1.val);
  47. if (flag & PUTW)
  48. emit2(loww(exp_1.val));
  49. }
  50. ea_2(sz, bits)
  51. {
  52. mrg_1 = mrg_2;
  53. exp_1 = exp_2;
  54. RELOMOVE(rel_1, rel_2);
  55. ea_1(sz, bits);
  56. }
  57. index(hibyte)
  58. {
  59. fit(fitb(exp_2.val));
  60. exp_2.val = hibyte | lowb(exp_2.val);
  61. }
  62. checksize(sz, bits)
  63. {
  64. if ((bits & (1 << (sz>>6))) == 0)
  65. serror("bad size");
  66. }
  67. test68010()
  68. {
  69. if (model != 1)
  70. warning("68010 instruction");
  71. }
  72. badoperand()
  73. {
  74. serror("bad operands");
  75. }
  76. shift_op(opc, sz)
  77. {
  78. if (mrg_1 < 010 && mrg_2 < 010) {
  79. emit2((opc&0170470) | sz | mrg_1<<9 | mrg_2);
  80. return;
  81. }
  82. if (exp_1.typ != S_ABS || mrg_1 != 074) {
  83. badoperand();
  84. return;
  85. }
  86. if (mrg_2 < 010) {
  87. fit(fit3(exp_1.val));
  88. emit2((opc&0170430) | sz | low3(exp_1.val)<<9 | mrg_2);
  89. return;
  90. }
  91. checksize(sz, 2);
  92. fit(exp_1.val == 1);
  93. emit2((opc&0177700) | mrg_2);
  94. ea_2(SIZE_W, MEM|ALT);
  95. }
  96. bitop(opc)
  97. {
  98. register bits;
  99. bits = DTA|ALT;
  100. if (opc == 0 && (mrg_1 < 010 || mrg_2 != 074))
  101. bits = DTA;
  102. if (mrg_1 < 010) {
  103. emit2(opc | 0400 | mrg_1<<9 | mrg_2);
  104. ea_2(0, bits);
  105. return;
  106. }
  107. if (mrg_1 == 074) {
  108. emit2(opc | 04000 | mrg_2);
  109. ea_1(SIZE_W, 0);
  110. ea_2(0, bits);
  111. return;
  112. }
  113. badoperand();
  114. }
  115. add(opc, sz)
  116. {
  117. if ((mrg_2 & 070) == 010)
  118. checksize(sz, 2|4);
  119. if (
  120. mrg_1 == 074
  121. &&
  122. small(
  123. exp_1.typ==S_ABS && fit3(exp_1.val),
  124. sz==SIZE_L ? 4 : 2
  125. )
  126. ) {
  127. emit2((opc&0400) | 050000 | low3(exp_1.val)<<9 | sz | mrg_2);
  128. ea_2(sz, ALT);
  129. return;
  130. }
  131. if (mrg_1 == 074 && (mrg_2 & 070) != 010) {
  132. emit2((opc&03000) | sz | mrg_2);
  133. ea_1(sz, 0);
  134. ea_2(sz, DTA|ALT);
  135. return;
  136. }
  137. if ((mrg_2 & 070) == 010) {
  138. emit2((opc&0170300) | (mrg_2&7)<<9 | sz<<1 | mrg_1);
  139. ea_1(sz, 0);
  140. return;
  141. }
  142. if (to_dreg(opc, sz, 0))
  143. return;
  144. if (from_dreg(opc, sz, ALT|MEM))
  145. return;
  146. badoperand();
  147. }
  148. and(opc, sz)
  149. {
  150. if (mrg_1 == 074 && mrg_2 >= 076) { /* ccr or sr */
  151. if (sz != SIZE_NON)
  152. checksize(sz, mrg_2==076 ? 1 : 2);
  153. else
  154. sz = (mrg_2==076 ? SIZE_B : SIZE_W);
  155. emit2((opc&07400) | sz | 074);
  156. ea_1(sz, 0);
  157. return;
  158. }
  159. if (sz == SIZE_NON)
  160. sz = SIZE_DEF;
  161. if (mrg_1 == 074) {
  162. emit2((opc&07400) | sz | mrg_2);
  163. ea_1(sz, 0);
  164. ea_2(sz, DTA|ALT);
  165. return;
  166. }
  167. if ((opc & 010000) == 0 && to_dreg(opc, sz, DTA))
  168. return;
  169. if (from_dreg(opc, sz, (opc & 010000) ? DTA|ALT : ALT|MEM))
  170. return;
  171. badoperand();
  172. }
  173. to_dreg(opc, sz, bits)
  174. {
  175. if ((mrg_2 & 070) != 000)
  176. return(0);
  177. emit2((opc & 0170000) | sz | (mrg_2&7)<<9 | mrg_1);
  178. ea_1(sz, bits);
  179. return(1);
  180. }
  181. from_dreg(opc, sz, bits)
  182. {
  183. if ((mrg_1 & 070) != 000)
  184. return(0);
  185. emit2((opc & 0170000) | sz | (mrg_1&7)<<9 | 0400 | mrg_2);
  186. ea_2(sz, bits);
  187. return(1);
  188. }
  189. cmp(sz)
  190. {
  191. register opc;
  192. if ((mrg_1&070) == 030 && (mrg_2&070) == 030) {
  193. emit2(0130410 | sz | (mrg_1&7) | (mrg_2&7)<<9);
  194. return;
  195. }
  196. if (mrg_1 == 074 && (mrg_2 & 070) != 010) {
  197. emit2(06000 | sz | mrg_2);
  198. ea_1(sz, 0);
  199. ea_2(sz, DTA|ALT);
  200. return;
  201. }
  202. if (mrg_2 < 020) {
  203. if (mrg_2 >= 010) {
  204. checksize(sz, 2|4);
  205. opc = 0130300 | sz<<1;
  206. mrg_2 &= 7;
  207. } else
  208. opc = 0130000 | sz;
  209. emit2(opc | mrg_2<<9 | mrg_1);
  210. ea_1(sz, 0);
  211. return;
  212. }
  213. badoperand();
  214. }
  215. move(sz)
  216. {
  217. register opc;
  218. if (mrg_1 > 074 || mrg_2 > 074) {
  219. move_special(sz);
  220. return;
  221. }
  222. if (sz == SIZE_NON)
  223. sz = SIZE_DEF;
  224. if (
  225. mrg_2<010
  226. &&
  227. mrg_1==074
  228. &&
  229. sz==SIZE_L
  230. &&
  231. small(exp_1.typ==S_ABS && fitb(exp_1.val), 4)
  232. ) {
  233. emit2(070000 | mrg_2<<9 | lowb(exp_1.val));
  234. return;
  235. }
  236. switch (sz) {
  237. case SIZE_B: opc = 010000; break;
  238. case SIZE_W: opc = 030000; break;
  239. case SIZE_L: opc = 020000; break;
  240. }
  241. emit2(opc | mrg_1 | (mrg_2&7)<<9 | (mrg_2&070)<<3);
  242. ea_1(sz, 0);
  243. ea_2(sz, ALT);
  244. }
  245. move_special(sz)
  246. {
  247. if (mrg_2 >= 076) {
  248. if (sz != SIZE_NON)
  249. checksize(sz, 2);
  250. emit2(042300 | (mrg_2==076?0:01000) | mrg_1);
  251. ea_1(SIZE_W, DTA);
  252. return;
  253. }
  254. if (mrg_1 >= 076) {
  255. if (mrg_1 == 076)
  256. test68010();
  257. if (sz != SIZE_NON)
  258. checksize(sz, 2);
  259. emit2(040300 | (mrg_1==076?01000:0) | mrg_2);
  260. ea_2(SIZE_W, DTA|ALT);
  261. return;
  262. }
  263. if (sz != SIZE_NON)
  264. checksize(sz, 4);
  265. if (mrg_1==075 && (mrg_2&070)==010) {
  266. emit2(047150 | (mrg_2&7));
  267. return;
  268. }
  269. if (mrg_2==075 && (mrg_1&070)==010) {
  270. emit2(047140 | (mrg_1&7));
  271. return;
  272. }
  273. badoperand();
  274. }
  275. movem(dr, sz, regs)
  276. {
  277. register i;
  278. register r;
  279. if ((mrg_2>>3) == 04) {
  280. r = regs; regs = 0;
  281. for (i = 0; i < 16; i++) {
  282. regs <<= 1;
  283. if (r & 1)
  284. regs++;
  285. r >>= 1;
  286. }
  287. }
  288. checksize(sz, 2|4);
  289. if ((mrg_2>>3)-3 == dr)
  290. badoperand();
  291. emit2(044200 | dr<<10 | (sz & 0200) >> 1 | mrg_2);
  292. emit2(regs);
  293. i = CTR;
  294. if (dr == 0 && (mrg_2&070) == 040)
  295. i = MEM;
  296. if (dr != 0 && (mrg_2&070) == 030)
  297. i = MEM;
  298. if (dr == 0)
  299. i |= ALT;
  300. ea_2(sz, i);
  301. }
  302. movep(sz)
  303. {
  304. checksize(sz, 2|4);
  305. if (mrg_1<010 && (mrg_2&070)==050) {
  306. emit2(0610 | (sz & 0200)>>1 | mrg_1<<9 | (mrg_2&7));
  307. ea_2(sz, 0);
  308. return;
  309. }
  310. if (mrg_2<010 && (mrg_1&070)==050) {
  311. emit2(0410 | (sz & 0200)>>1 | mrg_2<<9 | (mrg_1&7));
  312. ea_1(sz, 0);
  313. return;
  314. }
  315. badoperand();
  316. }
  317. branch(opc, exp)
  318. expr_t exp;
  319. {
  320. register sm;
  321. exp.val -= (DOTVAL + 2);
  322. if ((pass == PASS_2)
  323. &&
  324. (exp.val > 0)
  325. &&
  326. ((exp.typ & S_DOT) == 0)
  327. )
  328. exp.val -= DOTGAIN;
  329. sm = fitb(exp.val);
  330. if ((exp.typ & ~S_DOT) != DOTTYP)
  331. sm = 0;
  332. if (small(sm,2)) {
  333. if (exp.val == 0)
  334. emit2(047161); /* NOP */
  335. else
  336. emit2(opc | lowb(exp.val));
  337. } else {
  338. fit(fitw(exp.val));
  339. emit2(opc);
  340. #ifdef RELOCATION
  341. newrelo(exp.typ, RELPC|RELO2|RELBR|RELWR);
  342. #endif
  343. emit2(loww(exp.val));
  344. }
  345. }
  346. ea5x73(rg, sz)
  347. {
  348. if ((exp_2.typ & ~S_DOT) == DOTTYP) {
  349. /* pc relative with index */
  350. if (sz == SIZE_NON)
  351. sz = SIZE_DEF;
  352. exp_2.val -= (DOTVAL + 2);
  353. mrg_2 = 073;
  354. checksize(sz, 2|4);
  355. index(rg<<12 | (sz&0200)<<4);
  356. return;
  357. }
  358. /* displacement */
  359. mrg_2 = 050 | rg;
  360. if (pass == PASS_1) /* tricky, maybe 073 in next passes */
  361. return;
  362. if ((rg & 010) == 0 || sz != SIZE_NON)
  363. badoperand();
  364. }
  365. ea707172(sz)
  366. {
  367. register sm;
  368. mrg_2 = 071;
  369. switch (sz) {
  370. case SIZE_B:
  371. badoperand();
  372. case SIZE_W:
  373. mrg_2 = 070;
  374. case SIZE_L:
  375. return;
  376. case SIZE_NON:
  377. break;
  378. }
  379. if (pass == PASS_1) {
  380. /*
  381. * reserve a bit in the bittable
  382. * in the following passes one call to small()
  383. * will be done, but we don't know which one
  384. * since exp_2.typ cannot be trusted
  385. */
  386. small(0, 2);
  387. return;
  388. }
  389. if ((exp_2.typ & ~S_DOT) == DOTTYP) {
  390. sm = fitw(exp_2.val-(DOTVAL+2));
  391. sm = small(sm, 2);
  392. if (sm) { /* pc relative */
  393. exp_2.val -= (DOTVAL+2);
  394. mrg_2 = 072;
  395. }
  396. } else {
  397. sm = fitw(exp_2.val);
  398. #ifdef ASLD
  399. if (exp_2.typ & S_VAR)
  400. sm = 0;
  401. #else
  402. if (exp_2.typ != S_ABS)
  403. sm = 0;
  404. #endif ASLD
  405. sm = small(sm, 2);
  406. if (sm)
  407. mrg_2 = 070;
  408. }
  409. }
  410. ea6x(rg, ir, sz)
  411. {
  412. mrg_2 = 060 | rg;
  413. checksize(sz, 2|4);
  414. index(ir<<12 | (sz&0200)<<4);
  415. }
  416. ea72()
  417. {
  418. mrg_2 = 072;
  419. exp_2.val -= (DOTVAL + 2);
  420. }
  421. ea73(ri, sz)
  422. {
  423. mrg_2 = 073;
  424. exp_2.val -= (DOTVAL + 2);
  425. checksize(sz, 2|4);
  426. index(ri<<12 | (sz&0200)<<4);
  427. }