mach5.c 7.6 KB

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