开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 编译器/解释器 > 查看源码
GEXPR68.C
资源名称：c_compiler.zip　[点击查看]
上传用户：hlzzc88
上传日期：2007-01-06
资源大小：220k
文件大小：121k
源码类别：

编译器/解释器

开发平台：

Others

GEXPR68.C：源码内容
  1. /*
  2.  * 68K/386 32-bit C compiler.
  3.  *
  4.  * copyright (c) 1997, David Lindauer
  5.  * 
  6.  * This compiler is intended for educational use.  It may not be used
  7.  * for profit without the express written consent of the author.
  8.  *
  9.  * It may be freely redistributed, as long as this notice remains intact
  10.  * and either the original sources or derived sources 
  11.  * are distributed along with any executables derived from the originals.
  12.  *
  13.  * The author is not responsible for any damages that may arise from use
  14.  * of this software, either idirect or consequential.
  15.  *
  16.  * v1.35 March 1997
  17.  * David Lindauer, gclind01@starbase.spd.louisville.edu
  18.  *
  19.  * Credits to Mathew Brandt for original K&R C compiler
  20.  *
  21.  */
  22. #include        <stdio.h>
  23. #include        "expr.h"
  24. #include        "c.h"
  25. #include        "gen68.h"
  26. #include  "diag.h"
  28. /*
  29.  *      this module contains all of the code generation routines
  30.  *      for evaluating expressions and conditions.
  31.  */
  32. extern int stdinttype,stdunstype,stdintsize, stdldoublesize,stdaddrsize;
  33. extern int cf_freeaddress, cf_freedata;
  34. extern int linkreg,basereg;
  35. extern long stackdepth,framedepth;
  36. extern int prm_largedata, prm_68020,prm_phiform,prm_linkreg;
  37. extern int prm_smallcode, prm_rel, prm_smalldata;
  38. extern AMODE     push[], pop[];
  39. extern int prm_68020;
  40. extern SYM *currentfunc;
  41. extern long lc_maxauto;
  42. extern long nextlabel;
  43. extern char regstack[], rsold[], rsodepth,rsdepth;
  45. long bittab[32] = { 1,0x3,0x7,0xf,0x1f,0x3f,0x7f,0xff,
  46. 0x1ff,0x3ff,0x7ff,0xfff,0x1fff,0x3fff,0x7fff,0xffff,
  47. 0x1ffffL,0x3ffffL,0x7ffffL,0xfffffL,0x1fffffL,0x3fffffL,0x7fffffL,0xffffffL,
  48. 0x1ffffffL,0x3ffffffL,0x7ffffffL,0xfffffffL,0x1fffffffL,0x3fffffffL,0x7fffffffL,0xffffffffL
  49. };
  51. int chksize(int lsize, int rsize)
  52. {
  53. int l,r;
  54. l = lsize;
  55. r = rsize;
  56. if (l < 0) l = - l;
  57. if (r < 0) r = - r;
  58. return(l > r);
  59. }
  60. AMODE    *make_label(int lab)
  61. /*
  62.  *      construct a reference node for an internal label number.
  63.  */
  64. {       ENODE    *lnode;
  65.         AMODE    *ap;
  66.         lnode = xalloc(sizeof(ENODE));
  67.         lnode->nodetype = en_labcon;
  68.         lnode->v.i = lab;
  69.         ap = xalloc(sizeof(AMODE));
  70.         ap->mode = am_direct;
  71.         ap->offset = lnode;
  72.         return ap;
  73. }
  74. AMODE    *makebf(ENODE *node, AMODE *ap1, int size)
  75. /*
  76.  *      construct a bit field reference for 68020 bit field instructions
  77.  */
  78. {
  79.         AMODE    *ap;
  80. if (node->startbit == -1)
  81. DIAG("Illegal bit field");
  82.         ap = xalloc(sizeof(AMODE));
  83.         ap->mode = am_bf;
  84. ap->preg = node->startbit;
  85. ap->sreg = node->bits;
  86. switch (size) {
  87. case 1:
  88. case -1:
  89.   ap->preg =8-node->startbit-node->bits;
  90. break;
  91. case 2:
  92. case -2:
  93.   ap->preg =16-node->startbit-node->bits;
  94. break;
  95. case 4:
  96. case -4:
  97.   ap->preg =32-node->startbit-node->bits;
  98. break;
  99. }
  100.         return ap;
  101. }
  103. AMODE    *make_immed(long i)
  104. /*
  105.  *      make a node to reference an immediate value i.
  106.  */
  107. {       AMODE    *ap;
  108.         ENODE    *ep;
  109.         ep = xalloc(sizeof(ENODE));
  110.         ep->nodetype = en_icon;
  111.         ep->v.i = i;
  112.         ap = xalloc(sizeof(AMODE));
  113.         ap->mode = am_immed;
  114.         ap->offset = ep;
  115.         return ap;
  116. }
  118. AMODE    *make_offset(ENODE *node)
  119. /*
  120.  *      make a direct reference to a node.
  121.  */
  122. {       AMODE    *ap;
  123.         ap = xalloc(sizeof(AMODE));
  124.         ap->mode = am_direct;
  125.         ap->offset = node;
  126.         return ap;
  127. }
  128.         
  129. void tofloat(AMODE *ap,int size)
  130. {
  131. AMODE *ap2;
  132. freeop(ap);
  133. ap2 = temp_float();
  134.                 gen_codef(op_fmove,size,ap,ap2);
  135.                 ap->mode = am_freg;
  136.                 ap->preg = ap2->preg;
  137.                 ap->tempflag = 1;
  138. }
  139. void make_legal(AMODE *ap,int flags,int size)
  140. /*
  141.  *      make_legal will coerce the addressing mode in ap1 into a
  142.  *      mode that is satisfactory for the flag word.
  143.  */
  144. {       AMODE    *ap2;
  145.         if( ((flags & F_VOL) == 0) || ap->tempflag )
  146.                 {
  147.                 switch( ap->mode )
  148.                         {
  149. case am_freg:
  150. if (flags & F_FREG)
  151. return;
  152. break;
  153.                         case am_immed:
  154.                                 if( flags & F_IMMED )
  155.                                         return;         /* mode ok */
  156.                                 break;
  157.                         case am_areg:
  158.                                 if( flags & F_AREG )
  159.                                         return;
  160.                                 break;
  161.                         case am_dreg:
  162.                                 if( flags & F_DREG )
  163.                                         return;
  164.                                 break;
  165. case am_indx:
  166. case am_ind:
  167.                         case am_baseindxdata: 
  168.                         case am_baseindxaddr:
  169. case am_adirect:
  170. case am_ainc: case am_adec:
  171. if (flags & F_INDX)
  172. return;
  173. case am_direct:
  174.                         case am_pcindx:
  175.                                 if( flags & F_INDX )
  176.                                         return;
  177.                                 break;
  178.                         }
  179.                 }
  180. if (size > 4) {
  181. tofloat(ap,size);
  182. return;
  183.                 }
  184.         if( flags & F_DREG )
  185.                 {
  186. if (ap->mode == am_dreg && ap->tempflag)
  187. return;
  188.                 freeop(ap);             /* maybe we can use it... */
  189.                 ap2 = temp_data();      /* allocate to dreg */
  190.                 gen_code(op_move,size,ap,ap2);
  191.                 ap->mode = am_dreg;
  192.                 ap->preg = ap2->preg;
  193.                 ap->tempflag = 1;
  194.                 return;
  195.                 }
  196.         if( size == -1 )
  197.                 {
  198.                 freeop(ap);
  199.                 ap2 = temp_data();
  200.                 gen_code(op_move,1,ap,ap2);
  201.                 gen_code(op_ext,2,ap2,0);
  202.                 ap->mode = ap2->mode;
  203.                 ap->preg = ap2->preg;
  204.                 size = -2;
  205.                 }
  206.         if( size == 1 )
  207.                 {
  208.                 freeop(ap);
  209.                 ap2 = temp_data();
  210.                 gen_code(op_move,1,ap,ap2);
  211.                 gen_code(op_and,2,make_immed(0xff),ap2);
  212.                 ap->mode = ap2->mode;
  213.                 ap->preg = ap2->preg;
  214.                 size = 2;
  215.                 }
  216.          freeop(ap);
  217.          ap2 = temp_addr();
  218.          gen_code(op_move,size,ap,ap2);
  219.          ap->mode = am_areg;
  220.          ap->preg = ap2->preg;
  221.          ap->tempflag = 1;
  222. }
  223. void doshift(int op, AMODE *ap2, AMODE *ap1, int size)
  224. {
  225. if (ap2->mode == am_immed) {
  226. int temp = ap2->offset->v.i;
  227. while (temp >8) {
  228. temp = temp-8;
  229.          gen_code(op,size,make_immed(8),ap1);
  230. }
  231. if (temp != 0) {
  232. ap2->offset->v.i = temp;
  233.          gen_code(op,size,ap2,ap1);
  234. }
  235. }
  236. else
  237.          gen_code(op,size,ap2,ap1);
  238. }
  239. void bit_legal(AMODE *ap,ENODE *node, int size)
  240. {
  241. if (node->bits != -1) {
  242. if (prm_68020) {
  243. AMODE *ap1;
  244. if (ap->mode != am_dreg || !ap->tempflag) {
  245. ap1 = temp_data();
  246. ap1->tempflag = 1;
  247. }
  248. else
  249. ap1 = copy_addr(ap);
  250. gen_code3(op_bfextu,0,ap,makebf(node,ap1,size),ap1);
  251. ap->mode = ap1->mode;
  252. ap->preg = ap1->preg;
  253. ap->tempflag = ap1->tempflag;
  254. }
  255. else {
  256. make_legal(ap,F_DREG | F_VOL,size);
  257. if (node->startbit)
  258. doshift(op_asr,make_immed(node->startbit),ap,size);
  259. gen_code(op_asr,size,make_immed(node->startbit),ap);
  260. gen_code(op_andi,4,make_immed(bittab[node->bits-1]),ap);
  261. }
  262. }
  263. }
  264. AMODE *get_bitval(AMODE *ap,ENODE *node, int size)
  265. {
  266. AMODE *ap1 = temp_data();
  267. ap1->tempflag = TRUE;
  268. if (prm_68020) {
  269. gen_code3(op_bfextu,0,ap,makebf(node,ap,size),ap1);
  270. return ap1;
  271. }
  272. else {
  273. gen_code(op_move,size,ap,ap1);
  274. if (node->startbit)
  275. doshift(op_asr,make_immed(node->startbit),ap1,size);
  276. gen_code(op_andi,4,make_immed(bittab[node->bits-1]),ap1);
  277. return ap1;
  278. }
  279. }
  280. void bit_move(AMODE *ap1, AMODE *ap2, ENODE *node, int flags, int sizein, int sizeout)
  281. {
  282. if (prm_68020) {
  283. make_legal(ap1,F_DREG,sizein);
  284. gen_code3(op_bfins,0,ap1,ap2,makebf(node,ap2,sizeout));
  285. }
  286. else {
  287. gen_code(op_andi,sizeout,make_immed(~(bittab[node->bits-1]<<node->startbit)), ap2);
  288. if (ap1->mode == am_immed) {
  289. ap1->offset->v.i &= bittab[node->bits-1];
  290. if (ap1->offset->v.i) {
  291. ap1->offset->v.i <<= node->startbit;
  292. gen_code(op_ori,sizeout,ap1,ap2);
  293. if (!(flags & F_NOVALUE)) {
  294. make_legal(ap2,flags,sizeout);
  295. ap1->offset->v.i >>= node->startbit;
  296. gen_code(op_move,sizeout,ap1,ap2);
  297. }
  298. }
  299. }
  300. else {
  301. make_legal(ap1,F_DREG | F_VOL,sizein);
  302. gen_code(op_andi,sizein,make_immed(bittab[node->bits-1]), ap1);
  303. if (node->startbit)
  304. doshift(op_asl,make_immed(node->startbit),ap1,sizein);
  305. gen_code(op_or,sizeout,ap2,ap1);
  306. if (!(flags & F_NOVALUE)) {
  307. if (node->startbit)
  308. doshift(op_asr,make_immed(node->startbit),ap1,sizein);
  309. }
  310. }
  311. }
  312. }
  314. void do_extend(AMODE *ap,int isize,int osize,int flags)
  315. /*
  316.  *      if isize is not equal to osize then the operand ap will be
  317.  *      loaded into a register (if not already) and if osize is
  318.  *      greater than isize it will be extended to match.
  319.  */
  320. { AMODE *ap2;
  321.   if (osize == 0 || isize == 0)
  322. return;
  323.        if( isize == osize || isize == -osize)
  324.                 return;
  325. if (chksize(osize,isize) && osize <=4)
  326. if (isize ^ osize < 0)
  327. osize = -osize;
  328.         if( ap->mode != am_areg && ap->mode != am_dreg && isize <= 4) {
  329. if (flags&F_DREG) {
  330. freeop(ap);
  331. gen_code(op_move,isize,ap,ap2=temp_data());
  332. ap->mode = am_dreg;
  333. ap->preg = ap2->preg;
  334. }
  335. else if (isize ==1 || isize == -1) {
  336. freeop(ap);
  337. gen_code(op_move,isize,ap,ap2=temp_data());
  338. ap->mode = am_dreg;
  339. ap->preg = ap2->preg;
  340. freeop(ap);
  341. gen_code(op_ext,2,ap,0);
  342. gen_code(op_move,2,ap,ap2=temp_addr());
  343. ap->mode = am_areg;
  344. ap->preg = ap2->preg;
  345. }
  346. else {
  347. freeop(ap);
  348. gen_code(op_move,isize,ap,ap2=temp_addr());
  349. ap = ap2;
  350. }
  351. }
  352.         if( ap->mode == am_areg )
  353.                 return;         /* extend is automagic */
  355. switch(isize)
  356. {
  357.                 case -1:
  358. case 1:
  359. if (osize < 0)
  360. if (osize <= -4 && prm_68020)
  361. gen_code(op_extb,4,ap,0);
  362. else
  363.                          gen_code(op_ext,2,ap,0);
  364. else {
  365. int t = osize;
  366. if (osize > 4) t = 4;
  367. gen_code(op_andi,t,make_immed(0xff),ap);
  368. }
  369.                 case -2:
  370. case 2:
  371. if (osize == 1 || osize == -1)
  372. break;
  373.                          if( osize <-2 && !(prm_68020 && (isize == -1 || isize == 1))) {
  374.                            gen_code(op_ext,4,ap,0);
  375. }
  376. else
  377. if (isize == 2 || isize == -2) {
  378. gen_code(op_andi,4,make_immed(0xffff),ap);
  379. }
  380. case 4:
  381. case -4:
  382. if  (osize <=4)
  383. break;
  384. isize = -4;
  385. case 6:
  386. case 8: 
  387. if (osize > 4) {
  388. if (ap->mode != am_freg)
  389. tofloat(ap,isize);
  390. }
  391. else {
  392. freeop(ap);
  393. ap2 = temp_data();
  394. gen_codef(op_fmove,osize,ap,ap2);
  395. ap->mode = am_dreg;
  396. ap->preg = ap2->preg;
  397. }
  398. break;
  399. }
  400. }
  402. int     isshort(ENODE *node)
  403. /*
  404.  *      return true if the node passed can be generated as a short
  405.  *      offset.
  406.  */
  407. {       return (isintconst(node->nodetype) || node->nodetype == en_absacon)&&
  408.                 (node->v.i >= -32768L && node->v.i <= 32767L);
  409. }
  411. int     isbyte(ENODE *node)
  412. /*
  413.  *      return true if the node passed can be evaluated as a byte
  414.  *      offset.
  415.  */
  416. {       return isintconst(node->nodetype) &&
  417.                 (-128 <= node->v.i && node->v.i <= 127);
  418. }
  420. int isamshort(AMODE *ap)
  421. {
  422. long v;
  423. if (ap->offset->nodetype != en_icon)
  424. return TRUE;
  425. v = ap->offset->v.i;
  426. return (v >=-32768L && v < 32767);
  427. }
  428. int isamshort2(AMODE *ap, AMODE *ap2)
  429. {
  430. long v;
  431. if (ap->offset->nodetype != en_icon || ap2->offset->nodetype != en_icon)
  432. return TRUE;
  433. v = ap->offset->v.i + ap2->offset->v.i;
  434. return (v >=-32768L && v < 32767);
  435. }
  436. int isambyte(AMODE *ap)
  437. {
  438. long v;
  439. if (ap->offset->nodetype != en_icon)
  440. return FALSE;
  441. v = ap->offset->v.i;
  442. return (v >=-128 && v < 128);
  443. }
  444. int isambyte2(AMODE *ap, AMODE *ap2)
  445. {
  446. long v;
  447. if (ap->offset->nodetype != en_icon || ap2->offset->nodetype != en_icon)
  448. return FALSE;
  449. v = ap->offset->v.i + ap2->offset->v.i;
  450. return (v >=-128 && v < 128);
  451. }                            
  453. AMODE    *gen_index(int siz1,ENODE *node)
  454. /*
  455.  *      generate code to evaluate an index node (^+) and return
  456.  *      the addressing mode of the result. This routine takes no
  457.  *      flags since it always returns either am_ind or am_indx.
  458.  */
  459. {       AMODE    *ap1,*ap2, *ap3, *ap;
  460. ENODE node2;
  461. int scale;
  463. switch (node->v.p[0]->nodetype) {
  464. case en_icon:
  465. ap1 = gen_expr(node->v.p[0],F_IMMED,4);
  466. break;
  467. case en_lsh:
  468. if (prm_68020 && (scale = node->v.p[0]->v.p[1]->v.i) < 4 && scale) {
  469. ap1 = gen_expr(node->v.p[0]->v.p[0],F_IMMED | F_DREG | F_AREG,4);
  470. if (ap1->mode == am_immed) {
  471. while (--scale)
  472. ap1->offset->v.i <<=1;
  473. }
  474. else {
  475. if (ap1->mode == am_dreg)
  476. ap1->mode = am_baseindxdata;
  477. else
  478. ap1->mode = am_baseindxaddr;
  479. ap1->sreg = ap1->preg;
  480. ap1->preg = -1;
  481. ap1->scale = scale;
  482. ap1->offset = makenode(en_icon,0,0);
  483. }
  484. break;
  485. }
  486. default:
  487. mark();
  488. ap1 = gen_deref(node,F_INDX | F_DREG | F_AREG,4,FALSE);
  489. switch (ap1->mode) {
  490. case am_ainc:
  491. case am_adec:
  492. ap2 = temp_addr();
  493. gen_lea(siz1,ap1,ap2);
  494. freeop(ap1);
  495. ap1 = ap2;
  496. default:
  497. rsold[rsodepth-1] = rsdepth;
  498. break;
  499. case am_baseindxdata:
  500. case am_baseindxaddr:
  501. if (ap1->sreg >=0 && ap1->preg >= 0) {
  502. int t = rsold[rsodepth-1];
  503. freeop(ap1);
  504. ap3 = temp_addr();
  505. gen_lea(siz1,ap1,ap3);
  506. ap3->mode = am_ind;
  507. if (t <rsdepth-1 && ap3->preg + 8 == regstack[t+1])
  508. t+=2;
  509. if (t <rsdepth && ap3->preg + 8 == regstack[t])
  510. t+=1;
  511. ap1 = ap3;
  512. }
  514. }
  515. release();
  516. break;
  517. }
  519. switch (node->v.p[1]->nodetype) {
  520. case en_icon:
  521. ap2 = gen_expr(node->v.p[1],F_IMMED,4);
  522. break;
  523. case en_lsh:
  524. if (prm_68020 && (scale = node->v.p[1]->v.p[1]->v.i) < 4 && scale) {
  525. if (node->v.p[1]->v.p[0]->nodetype == en_tempref)
  526. ap2 = gen_expr(node->v.p[1]->v.p[0],F_IMMED | F_DREG | F_AREG,4);
  527. if (ap2->mode == am_immed) {
  528. while (--scale)
  529. ap2->offset->v.i <<=1;
  530. }
  531. else {
  532. if (ap2->mode == am_dreg)
  533. ap2->mode = am_baseindxdata;
  534. else
  535. ap2->mode = am_baseindxaddr;
  536. ap2->sreg = ap1->preg;
  537. ap2->preg = -1;
  538. ap2->scale = scale;
  539. ap2->offset = makenode(en_icon,0,0);
  540. }
  541. break;
  542. }
  543. default:      {
  544. int flag = ap1->mode == am_areg || ap1->mode == am_ind ||
  545. ap1->mode == am_indx || ap1->mode == am_baseindxaddr;
  546. node2.v.p[0] = node->v.p[1];
  547. node2.nodetype = node->nodetype;
  548. mark();
  549. ap2 = gen_deref(&node2,F_INDX | F_DREG | F_AREG,4,flag);
  550. switch (ap1->mode) {
  551. case am_ainc:
  552. case am_adec:
  553. ap3 = temp_addr();
  554. gen_lea(siz1,ap2,ap3);
  555. freeop(ap2);
  556. ap2 = ap3;
  557. default:
  558. rsold[rsodepth-1] = rsdepth;
  559. break;
  560. case am_baseindxdata:
  561. case am_baseindxaddr:
  562. if (ap2->sreg >=0 && ap2->preg >= 0) {
  563. int t = rsold[rsodepth-1];
  564. freeop(ap2);
  565. ap3 = temp_addr();
  566. gen_lea(siz1,ap2,ap3);
  567. ap3->mode = am_ind;
  568. if (t <rsdepth-1 && ap3->preg + 8 == regstack[t+1])
  569. t+=2;
  570. if (t <rsdepth && ap3->preg + 8 == regstack[t])
  571. t+=1;
  572. ap2 = ap3;
  573. }
  574. }
  575. release();
  576. }
  577. break;
  578. }
  579. tryagain:
  580. switch(ap1->mode) {
  581. case am_areg:
  582. switch (ap2->mode) {
  583. case am_areg:
  584. ap1->sreg = ap2->preg;
  585. ap1->mode = am_baseindxaddr;
  586. ap1->offset = makenode(en_icon,0,0);
  587. ap1->scale = 0;
  588. return ap1;
  589. case am_dreg:
  590. ap1->sreg = ap2->preg;
  591. ap1->mode = am_baseindxdata;
  592. ap1->offset = makenode(en_icon,0,0);
  593. ap1->scale = 0;
  594. return ap1;
  595. case am_adirect:
  596. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  597. ap1->mode = am_indx;
  598. ap1->offset = ap2->offset;
  599. return ap1;
  600. }
  601. ap = temp_addr();
  602. gen_lea(0,ap2,ap);
  603. ap1->mode = am_baseindxaddr;
  604. ap1->offset = makenode(en_icon,0,0);
  605. ap1->scale = 0;
  606. ap1->sreg = ap->preg;
  607. return ap1;
  608. case am_immed:
  609. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  610. ap1->mode = am_indx;
  611. ap1->offset = ap2->offset;
  612. return ap1;
  613. }
  614. ap = temp_data();
  615. gen_code(op_move,4,ap2,ap);
  616. ap1->mode = am_baseindxdata;
  617. ap1->offset = makenode(en_icon,0,0);
  618. ap1->scale = 0;
  619. ap1->sreg = ap->preg;
  620. return ap1;
  621. case am_indx:
  622. if (prm_68020 || isambyte(ap2)) {
  623. ap1->mode = am_baseindxaddr;
  624. ap1->offset = ap2->offset;
  625. ap1->scale = 0;
  626. ap1->sreg = ap2->preg;
  627. return ap1;
  628. }
  629. freeop(ap2);
  630. ap = temp_addr();
  631. gen_lea(0,ap2,ap);
  632. ap->mode = am_baseindxaddr;
  633. ap->sreg = ap1->preg;
  634. ap->scale = 0;
  635. ap->offset = makenode(en_icon,0,0);
  636. return ap;
  637. case am_ind:
  638. ap1->mode = am_baseindxaddr;
  639. ap1->offset = makenode(en_icon,0,0);
  640. ap1->scale = 0;
  641. ap1->sreg = ap2->preg;
  642. return ap1;
  643. case am_baseindxaddr:
  644. case am_baseindxdata:
  645. if (ap2->preg == -1) {
  646. ap2->preg = ap1->preg;
  647. return ap2;
  648. }
  649. freeop(ap2);
  650. ap = temp_addr();
  651. gen_lea(0,ap2,ap);
  652. ap1->mode = am_baseindxaddr;
  653. ap1->scale = 0;
  654. ap1->offset = makenode(en_icon,0,0);
  655. ap1->sreg = ap->preg;
  656. return ap1;
  657. }
  658. break;
  659. case am_dreg:
  660. switch (ap2->mode) {
  661. case am_areg:
  662. ap2->sreg = ap1->preg;
  663. ap2->mode = am_baseindxdata;
  664. ap2->offset = makenode(en_icon,0,0);
  665. ap2->scale = 0;
  666. return ap2;
  667. case am_dreg:
  668. freeop(ap2);
  669. ap = temp_addr();
  670. gen_lea(0,ap1,ap);
  671. ap->sreg = ap1->preg;
  672. ap->mode = am_baseindxdata;
  673. ap->offset = makenode(en_icon,0,0);
  674. ap->scale = 0;
  675. return ap;
  676. case am_adirect:
  677. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  678. freeop(ap1);
  679. ap = temp_addr();
  680. gen_code(op_move,4,ap1,ap);
  681. ap->mode = am_indx;
  682. ap->offset = ap2->offset;
  683. return ap;
  684. }
  685. ap = temp_addr();
  686. gen_lea(0,ap2,ap);
  687. ap->mode = am_baseindxdata;
  688. ap->offset = makenode(en_icon,0,0);
  689. ap->scale = 0;
  690. ap->sreg = ap1->preg;
  691. return ap;
  692. case am_immed:
  693. if (prm_68020 || isamshort(ap2)) {
  694. freeop(ap1);
  695. ap = temp_addr();
  696. gen_code(op_move,4,ap1,ap);
  697. ap->mode = am_indx;
  698. ap->offset = ap2->offset;
  699. return ap;
  700. }
  701. ap = temp_addr();
  702. gen_code(op_move,0,ap2,ap);
  703. ap->mode = am_baseindxdata;
  704. ap->offset = makenode(en_icon,0,0);
  705. ap->scale = 0;
  706. ap->sreg = ap1->preg;
  707. return ap;
  708. case am_indx:
  709. if (prm_68020 || isambyte(ap2)) {
  710. ap2->mode = am_baseindxdata;
  711. ap2->scale = 0;
  712. ap2->sreg = ap1->preg;
  713. return ap2;
  714. }
  715. freeop(ap2);
  716. ap = temp_addr();
  717. gen_lea(0,ap2,ap);
  718. ap->mode = am_baseindxdata;
  719. ap->sreg = ap1->preg;
  720. ap->scale = 0;
  721. ap->offset = makenode(en_icon,0,0);
  722. return ap;
  723. case am_ind:
  724. ap2->mode = am_baseindxdata;
  725. ap2->offset = makenode(en_icon,0,0);
  726. ap2->scale = 0;
  727. ap2->sreg = ap1->preg;
  728. return ap2;
  729. case am_baseindxaddr:
  730. case am_baseindxdata:
  731. if (ap2->preg == -1) {
  732. ap = temp_addr();
  733. gen_code(op_move,4,ap1,ap);
  734. ap2->preg = ap->preg;
  735. return ap2;
  736. }
  737. freeop(ap2);
  738. ap = temp_addr();
  739. gen_lea(0,ap2,ap);
  740. ap->mode = am_baseindxdata;
  741. ap->scale = 0;
  742. ap->offset = makenode(en_icon,0,0);
  743. ap->sreg = ap1->preg;
  744. return ap;
  745. }
  746. break;
  747. case am_adirect:
  748. switch (ap2->mode) {
  749. case am_areg:
  750. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  751. ap2->mode = am_indx;
  752. ap2->offset = ap1->offset;
  753. return ap2;
  754. }
  755. ap = temp_addr();
  756. gen_lea(0,ap1,ap);
  757. ap2->mode = am_baseindxaddr;
  758. ap2->offset = makenode(en_icon,0,0);
  759. ap2->scale = 0;
  760. ap2->sreg = ap->preg;
  761. return ap2;
  762. case am_dreg:
  763. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  764. freeop(ap1);
  765. ap = temp_addr();
  766. gen_code(op_move,4,ap2,ap);
  767. ap->mode = am_indx;
  768. ap->offset = ap1->offset;
  769. return ap;
  770. }
  771. ap = temp_addr();
  772. gen_lea(0,ap1,ap);
  773. ap->mode = am_baseindxdata;
  774. ap->offset = makenode(en_icon,0,0);
  775. ap->scale = 0;
  776. ap->sreg = ap2->preg;
  777. return ap;
  778. case am_adirect:
  779. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  780. return ap1;
  781. case am_immed:
  782. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  783. return ap1;
  784. case am_indx:
  785. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  786. ap2->offset = makenode(en_add,ap2->offset,ap1->offset);
  787. return ap2;
  788. }
  789. ap = temp_addr();
  790. gen_lea(0,ap1,ap);
  791. ap2->mode = am_baseindxaddr;
  792. ap2->sreg = ap->preg;
  793. ap2->scale = 0;
  794. return ap2;
  795. case am_ind:
  796. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  797. ap2->offset = ap1->offset;
  798. ap2->mode = am_indx;
  799. return ap2;
  800. }
  801. ap = temp_addr();
  802. gen_lea(0,ap1,ap);
  803. ap2->mode = am_baseindxaddr;
  804. ap2->sreg = ap->preg;
  805. ap2->scale = 0;
  806. ap2->offset = makenode(en_icon,0,0);
  807. return ap2;
  808. case am_baseindxaddr:
  809. case am_baseindxdata:
  810. if (prm_68020) {
  811. ap2->offset = makenode(en_add,ap2->offset,ap1->offset);
  812. return ap2;
  813. }
  814. if (ap2->preg == -1) {
  815. ap = temp_addr();
  816. ap2->preg = ap->preg;
  817. gen_lea(0,ap1,ap);
  818. return ap2;
  819. }
  820. ap = temp_addr();
  821. gen_lea(0,ap1,ap);
  822. ap2->mode = am_baseindxaddr;
  823. ap2->sreg = ap->preg;
  824. ap2->scale = 0;
  825. ap2->offset = makenode(en_icon,0,0);
  826. return ap2;
  827. }
  828. break;
  829. case am_immed:
  830. switch (ap2->mode) {
  831. case am_areg:
  832. if (prm_68020 || isamshort(ap1)) {
  833. ap2->mode = am_indx;
  834. ap2->offset = ap1->offset;
  835. return ap2;
  836. }
  837. ap = temp_data();
  838. gen_code(op_move,4,ap1,ap);
  839. ap2->mode = am_baseindxdata;
  840. ap2->offset = makenode(en_icon,0,0);
  841. ap2->scale = 0;
  842. ap2->sreg = ap->preg;
  843. return ap2;
  844. case am_dreg:
  845. if (prm_68020 || isamshort(ap1)) {
  846. freeop(ap2);
  847. ap = temp_addr();
  848. gen_code(op_move,4,ap2,ap);
  849. ap->mode = am_indx;
  850. ap->offset = ap1->offset;
  851. return ap;
  852. }
  853. ap = temp_addr();
  854. gen_code(op_move,0,ap1,ap);
  855. ap->mode = am_baseindxdata;
  856. ap->offset = makenode(en_icon,0,0);
  857. ap->scale = 0;
  858. ap->sreg = ap2->preg;
  859. return ap;
  860. case am_adirect:
  861. ap2->offset = makenode(en_add,ap2->offset,ap1->offset);
  862. return ap2;
  863. case am_immed:
  864. if (prm_68020 || isamshort2(ap1,ap2)) {
  865. ap1->offset->v.i += ap2->offset->v.i;
  866. return ap1;
  867. }
  868. if (isamshort(ap1)) {
  869. ap = temp_addr();
  870. gen_code(op_move,4,ap2,ap);
  871. ap->mode = am_indx;
  872. ap->offset = ap1->offset;
  873. return ap;
  874. }
  875. if (isamshort(ap2)) {
  876. ap = temp_addr();
  877. gen_code(op_move,4,ap1,ap);
  878. ap->mode = am_indx;
  879. ap->offset = ap2->offset;
  880. return ap;
  881. }
  882. ap = temp_addr();
  883. ap3 = temp_data();
  884. gen_code(op_move,4,ap1,ap);
  885. gen_code(op_move,4,ap2,ap3);
  886. ap->mode = am_baseindxdata;
  887. ap->sreg = ap3->preg;
  888. ap->scale = 0;
  889. ap->offset = makenode(en_icon,0,0);
  890. return ap;
  891. case am_indx:
  892. if (prm_68020 || isamshort2(ap1,ap2)) {
  893. if (ap2->offset->nodetype == en_icon)
  894. ap2->offset->v.i += ap1->offset->v.i;
  895. else
  896. ap2->offset = makenode(en_add,ap2->offset,ap1->offset);
  897. return ap2;
  898. }
  899. ap = temp_data();
  900. gen_code(op_move,4,ap2,ap);
  901. ap1->mode = am_baseindxdata;
  902. ap1->scale = 0;
  903. ap1->sreg = ap->preg;
  904. return ap1;
  905. case am_baseindxaddr:
  906. case am_baseindxdata:
  907. if (ap2->preg == -1 && !prm_68020) {
  908. ap = temp_addr();
  909. gen_code(op_move,4,ap1,ap);
  910. ap2->preg = ap->preg;
  911. return ap2;
  912. }
  913. if (prm_68020 || isambyte2(ap1,ap2)) {
  914. if (ap2->offset->nodetype == am_immed)
  915. ap2->offset->v.i += ap1->offset->v.i;
  916. else
  917. ap2->offset = makenode(en_add,ap2->offset,ap1->offset);
  918. return ap2;
  919. }
  920. freeop(ap2);
  921. ap = temp_addr();
  922. gen_lea(0,ap2,ap);
  923. ap->mode = am_ind;
  924. ap2 = ap;
  925. /* drop through */
  926. case am_ind:
  927. if (prm_68020 || isamshort(ap1)) {
  928. ap2->offset = ap1->offset;
  929. ap2->mode = am_indx;
  930. return ap2;
  931. }
  932. ap = temp_data();
  933. gen_code(op_move,4,ap1,ap);
  934. ap2->mode = am_baseindxdata;
  935. ap2->scale = 0;
  936. ap2->sreg = ap->preg;
  937. ap2->offset = makenode(en_icon,0,0);
  938. return ap2;
  939. }
  940. break;
  941. case am_indx:
  942. switch (ap2->mode) {
  943. case am_areg:
  944. if (prm_68020 || isambyte(ap1)) {
  945. ap2->mode = am_baseindxaddr;
  946. ap2->offset = ap1->offset;
  947. ap2->scale = 0;
  948. ap2->sreg = ap2->preg;
  949. return ap2;
  950. }
  951. freeop(ap1);
  952. ap = temp_addr();
  953. gen_lea(0,ap1,ap);
  954. ap->mode = am_baseindxaddr;
  955. ap->sreg = ap2->preg;
  956. ap->scale = 0;
  957. ap->offset = makenode(en_icon,0,0);
  958. return ap;
  959. case am_dreg:
  960. if (prm_68020 || isambyte(ap1)) {
  961. ap1->mode = am_baseindxdata;
  962. ap1->scale = 0;
  963. ap1->sreg = ap2->preg;
  964. return ap1;
  965. }
  966. freeop(ap1);
  967. ap = temp_addr();
  968. gen_lea(0,ap1,ap);
  969. ap->mode = am_baseindxdata;
  970. ap->sreg = ap2->preg;
  971. ap->scale = 0;
  972. ap->offset = makenode(en_icon,0,0);
  973. return ap;
  974. case am_adirect:
  975. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  976. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  977. return ap1;
  978. }
  979. ap = temp_addr();
  980. gen_lea(0,ap2,ap);
  981. ap1->mode = am_baseindxaddr;
  982. ap1->sreg = ap->preg;
  983. ap1->scale = 0;
  984. return ap1;
  985. case am_immed:
  986. if (prm_68020 || isamshort2(ap1,ap2)) {
  987. if (ap1->offset->nodetype == am_immed)
  988. ap1->offset->v.i += ap2->offset->v.i;
  989. else
  990. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  991. return ap1;
  992. }
  993. ap = temp_data();
  994. gen_code(op_move,4,ap2,ap);
  995. ap1->mode = am_baseindxdata;
  996. ap1->scale = 0;
  997. ap1->sreg = ap->preg;
  998. return ap1;
  999. case am_indx:
  1000. if (isambyte2(ap1,ap2) || prm_68020) {
  1001. if (ap1->offset->nodetype == am_immed && ap2->offset->nodetype)
  1002. ap1->offset->v.i += ap2->offset->v.i;
  1003. else
  1004. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  1005. ap1->mode = am_baseindxaddr;
  1006. ap1->sreg = ap2->preg;
  1007. ap1->scale = 0;
  1008. ap1->offset = makenode(en_icon,0,0);
  1009. return ap1;
  1010. }
  1011. if (isambyte(ap1)) {
  1012. freeop(ap2);
  1013. ap = temp_addr();
  1014.     gen_lea(0,ap2,ap);
  1015. ap1->mode = am_baseindxaddr;
  1016. ap1->sreg = ap->preg;
  1017. ap1->scale = 0;
  1018. ap1->offset = makenode(en_icon,0,0);
  1019. return ap1;
  1020. }
  1021. if (isambyte(ap2)) {
  1022. freeop(ap1);
  1023. ap = temp_addr();
  1024.     gen_lea(0,ap1,ap);
  1025. ap2->mode = am_baseindxaddr;
  1026. ap2->sreg = ap->preg;
  1027. ap2->scale = 0;
  1028. ap2->offset = makenode(en_icon,0,0);
  1029. return ap2;
  1030. }
  1031. freeop(ap1);
  1032. ap = temp_addr();
  1033. gen_lea(0,ap1,ap);
  1034. freeop(ap2);
  1035. ap1 = temp_addr();
  1036. gen_lea(0,ap2,ap1);
  1037. ap1->sreg = ap->preg;
  1038. ap1->mode = am_baseindxaddr;
  1039. ap1->scale = 0;
  1040. ap1->offset = makenode(en_icon,0,0);
  1041. return ap1;
  1042. case am_ind:
  1043. if (isambyte(ap1) || prm_68020) {
  1044. ap1->mode = am_baseindxaddr;
  1045. ap1->sreg = ap2->preg;
  1046. ap1->scale = 0;
  1047. return ap1;
  1048. }
  1049. freeop(ap1);
  1050. ap = temp_addr();
  1051. gen_lea(0,ap1,ap);
  1052. ap2->sreg = ap->preg;
  1053. ap2->mode = am_baseindxaddr;
  1054. ap2->scale = 0;
  1055. ap2->offset = makenode(en_icon,0,0);
  1056. return ap2;
  1057. case am_baseindxaddr:
  1058. case am_baseindxdata:
  1059. if (prm_68020 || isambyte2(ap1,ap2)) {
  1060. if (ap2->preg == -1) {
  1061. ap2->preg = ap1->preg;
  1062. if (ap2->offset->nodetype == am_immed && ap1->offset->nodetype == am_immed)
  1063. ap2->offset->v.i+= ap1->offset->v.i;
  1064. else
  1065. ap2->offset = makenode(en_add,ap2->offset, ap1->offset);
  1066. return ap2;
  1067. }
  1068. freeop(ap2);
  1069. ap = temp_addr();
  1070. gen_lea(0,ap2,ap);
  1071. ap->mode = am_baseindxaddr;
  1072. ap->sreg = ap1->preg;
  1073. ap->scale = 0;
  1074. ap->offset = ap1->offset;
  1075. return ap;
  1076. }
  1077. if (ap2->preg == -1) {
  1078. ap3 = xalloc(sizeof(AMODE));
  1079. ap3->preg = ap2->sreg;
  1080. if (ap2->mode == am_baseindxdata) {
  1081. ap3->mode = F_DREG;
  1082. if (ap3->preg < cf_freedata)
  1083. ap3->tempflag = 1;
  1084. }
  1085. else {
  1086. ap3->mode = F_AREG;
  1087. if (ap3->preg < cf_freeaddress)
  1088. ap3->tempflag = 1;
  1089. }
  1090. if (ap2->scale) {
  1091. make_legal(ap3,F_DREG | F_VOL,4);
  1092. gen_code(op_asl,4,ap3,make_immed(ap2->scale));
  1093. make_legal(ap3,F_AREG | F_VOL,4);
  1094. }
  1095. else
  1096. make_legal(ap3,F_AREG,4);
  1097. ap2->preg = ap3->preg;
  1098. ap2->mode = am_indx;
  1099. return ap2;
  1100. }
  1101. freeop(ap2);
  1102. ap = temp_addr();
  1103. gen_lea(0,ap2,ap);
  1104. ap2 = temp_data();
  1105. gen_code(op_move,4,ap,ap2);
  1106. freeop(ap1);
  1107. gen_lea(0,ap1,ap);
  1108. ap->mode = am_baseindxdata;
  1109. ap->sreg = ap2->preg;
  1110. ap->scale = 0;
  1111. ap->offset = makenode(en_icon,0,0);
  1112. return ap;
  1113. }
  1114. break;
  1115. case am_ind:
  1116. switch (ap2->mode) {
  1117. case am_areg:
  1118. ap2->mode = am_baseindxaddr;
  1119. ap2->offset = makenode(en_icon,0,0);
  1120. ap2->scale = 0;
  1121. ap2->sreg = ap1->preg;
  1122. return ap2;
  1123. case am_dreg:
  1124. ap1->mode = am_baseindxdata;
  1125. ap1->offset = makenode(en_icon,0,0);
  1126. ap1->scale = 0;
  1127. ap1->sreg = ap2->preg;
  1128. return ap1;
  1129. case am_adirect:
  1130. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  1131. ap1->offset = ap2->offset;
  1132. ap1->mode = am_indx;
  1133. return ap1;
  1134. }
  1135. ap = temp_addr();
  1136. gen_lea(0,ap2,ap);
  1137. ap1->mode = am_baseindxaddr;
  1138. ap1->sreg = ap->preg;
  1139. ap1->scale = 0;
  1140. ap1->offset = makenode(en_icon,0,0);
  1141. return ap1;
  1142. case am_immed:
  1143. if (prm_68020 || isamshort(ap2)) {
  1144. ap1->offset = ap2->offset;
  1145. ap1->mode = am_indx;
  1146. return ap1;
  1147. }
  1148. ap = temp_data();
  1149. gen_code(op_move,4,ap2,ap);
  1150. ap1->mode = am_baseindxdata;
  1151. ap1->scale = 0;
  1152. ap1->sreg = ap->preg;
  1153. ap1->offset = makenode(en_icon,0,0);
  1154. return ap1;
  1155. case am_indx:
  1156. if (isambyte(ap2) || prm_68020) {
  1157. ap2->mode = am_baseindxaddr;
  1158. ap2->sreg = ap1->preg;
  1159. return ap2;
  1160. }
  1161. freeop(ap2);
  1162. ap = temp_addr();
  1163. gen_lea(0,ap2,ap);
  1164. ap1->sreg = ap->preg;
  1165. ap1->mode = am_baseindxaddr;
  1166. ap1->scale = 0;
  1167. ap1->offset = makenode(en_icon,0,0);
  1168. return ap1;
  1169. case am_ind:
  1170. ap1->mode = am_baseindxaddr;
  1171. ap1->sreg= ap2->preg;
  1172. ap1->scale = 0;
  1173. ap1->offset = makenode(en_icon,0,0);
  1174. return ap1;
  1175. case am_baseindxaddr:
  1176. case am_baseindxdata:
  1177. if (ap2->preg == -1) {
  1178. ap2->preg = ap1->preg;
  1179. return ap2;
  1180. }
  1181. freeop(ap2);
  1182. ap = temp_addr();
  1183. gen_lea(0,ap2,ap);
  1184. ap->mode = am_baseindxaddr;
  1185. ap->sreg = ap1->preg;
  1186. ap->scale = 0;
  1187. ap->offset = makenode(en_icon,0,0);
  1188. return ap;
  1189. }
  1190. break;
  1191. case am_baseindxaddr:
  1192. switch (ap2->mode) {
  1193. case am_areg:
  1194. if (ap1->preg == -1) {
  1195. ap1->preg = ap2->preg;
  1196. return ap1;
  1197. }
  1198. freeop(ap1);
  1199. ap = temp_addr();
  1200. gen_lea(0,ap1,ap);
  1201. ap2->mode = am_baseindxaddr;
  1202. ap2->scale = 0;
  1203. ap2->offset = makenode(en_icon,0,0);
  1204. ap2->sreg = ap->preg;
  1205. return ap2;
  1206. case am_dreg:
  1207. if (ap1->preg == -1) {
  1208. ap = temp_addr();
  1209. gen_code(op_move,4,ap2,ap);
  1210. ap1->preg = ap->preg;
  1211. return ap1;
  1212. }
  1213. freeop(ap1);
  1214. ap = temp_addr();
  1215. gen_lea(0,ap1,ap);
  1216. ap->mode = am_baseindxdata;
  1217. ap->scale = 0;
  1218. ap->offset = makenode(en_icon,0,0);
  1219. ap->sreg = ap2->preg;
  1220. return ap;
  1221. case am_adirect:
  1222. if (prm_68020) {
  1223. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  1224. return ap1;
  1225. }
  1226. if (ap1->preg == -1) {
  1227. ap = temp_addr();
  1228. ap1->preg = ap->preg;
  1229. gen_lea(0,ap2,ap);
  1230. return ap1;
  1231. }
  1232. ap = temp_addr();
  1233. gen_lea(0,ap2,ap);
  1234. ap1->mode = am_baseindxaddr;
  1235. ap1->sreg = ap->preg;
  1236. ap1->scale = 0;
  1237. ap1->offset = makenode(en_icon,0,0);
  1238. return ap1;
  1239. case am_immed:
  1240. if (!prm_68020 && ap1->preg == -1) {
  1241. ap = temp_addr();
  1242. gen_code(op_move,4,ap2,ap);
  1243. ap1->preg = ap->preg;
  1244. return ap1;
  1245. }
  1246. if (prm_68020 || isambyte2(ap1,ap2)) {
  1247. if (ap1->offset->nodetype == am_immed)
  1248. ap1->offset->v.i += ap2->offset->v.i;
  1249. else
  1250. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  1251. return ap1;
  1252. }
  1253. freeop(ap1);
  1254. ap = temp_addr();
  1255. gen_lea(0,ap1,ap);
  1256. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  1257. ap->mode = am_indx;
  1258. ap->offset = ap2->offset;
  1259. return ap;
  1260. }
  1261. ap1 = temp_data();
  1262. ap1->mode = am_baseindxdata;
  1263. ap1->sreg = ap->preg;
  1264. ap1->scale = 0;
  1265. ap1->offset = makenode(en_icon,0,0);
  1266. return ap1;
  1267. case am_indx:
  1268. if (prm_68020 || isambyte2(ap1,ap2)) {
  1269. if (ap1->preg == -1) {
  1270. ap1->preg = ap2->preg;
  1271. if (ap2->offset->nodetype == am_immed && ap1->offset->nodetype == am_immed)
  1272. ap1->offset->v.i+= ap2->offset->v.i;
  1273. else
  1274. ap1->offset = makenode(en_add,ap1->offset, ap2->offset);
  1275. return ap1;
  1276. }
  1277. freeop(ap1);
  1278. ap = temp_addr();
  1279. gen_lea(0,ap1,ap);
  1280. ap->mode = am_baseindxaddr;
  1281. ap->sreg = ap2->preg;
  1282. ap->scale = 0;
  1283. ap->offset = ap2->offset;
  1284. return ap;
  1285. }
  1286. if (ap1->preg == -1) {
  1287. ap3 = xalloc(sizeof(AMODE));
  1288. ap3->preg = ap1->sreg;
  1289. if (ap1->mode == am_baseindxdata) {
  1290. ap3->mode = F_DREG;
  1291. if (ap3->preg < cf_freedata)
  1292. ap3->tempflag = 1;
  1293. }
  1294. else {
  1295. ap3->mode = F_AREG;
  1296. if (ap3->preg < cf_freeaddress)
  1297. ap3->tempflag = 1;
  1298. }
  1299. if (ap1->scale) {
  1300. make_legal(ap3,F_DREG | F_VOL,4);
  1301. gen_code(op_asl,4,ap3,make_immed(ap1->scale));
  1302. make_legal(ap3,F_AREG | F_VOL,4);
  1303. }
  1304. else
  1305. make_legal(ap3,F_AREG,4);
  1306. ap1->preg = ap3->preg;
  1307. ap1->mode = am_indx;
  1308. return ap1;
  1309. }
  1310. freeop(ap1);
  1311. ap = temp_addr();
  1312. gen_lea(0,ap1,ap);
  1313. ap1 = temp_data();
  1314. gen_code(op_move,4,ap,ap1);
  1315. freeop(ap2);
  1316. ap = temp_addr();
  1317. gen_lea(0,ap2,ap);
  1318. ap->mode = am_baseindxdata;
  1319. ap->sreg = ap1->preg;
  1320. ap->scale = 0;
  1321. ap->offset = makenode(en_icon,0,0);
  1322. return ap;
  1323. case am_ind:
  1324. if (ap1->preg == -1) {
  1325. ap1->preg = ap2->preg;
  1326. return ap1;
  1327. }
  1328. freeop(ap1);
  1329. ap = temp_addr();
  1330. gen_lea(0,ap1,ap);
  1331. ap->mode = am_baseindxaddr;
  1332. ap->sreg = ap2->preg;
  1333. ap->scale = 0;
  1334. ap->offset = ap1->offset;
  1335. return ap;
  1336. case am_baseindxaddr:
  1337. case am_baseindxdata:
  1338. if (prm_68020 || (ap1->preg != -1 && ap2->preg != -1)) {
  1339. freeop(ap1);
  1340. ap = temp_addr();
  1341. gen_lea(0,ap1,ap);
  1342. ap1 = temp_data();
  1343. gen_code(op_move,4,ap,ap1);
  1344. freeop(ap2);
  1345. gen_lea(0,ap2,ap);
  1346. ap->mode = am_baseindxdata;
  1347. ap->sreg = ap1->preg;
  1348. ap->scale = 0;
  1349. ap->offset = makenode(en_icon,0,0);
  1350. return ap;
  1351. }
  1352. if (ap1->preg == -1) {
  1353. ap3 = xalloc(sizeof(AMODE));
  1354. ap3->preg = ap1->sreg;
  1355. if (ap1->mode == am_baseindxdata) {
  1356. ap3->mode = F_DREG;
  1357. if (ap3->preg < cf_freedata)
  1358. ap3->tempflag = 1;
  1359. }
  1360. else {
  1361. ap3->mode = F_AREG;
  1362. if (ap3->preg < cf_freeaddress)
  1363. ap3->tempflag = 1;
  1364. }
  1365. if (ap1->scale) {
  1366. make_legal(ap3,F_DREG | F_VOL,4);
  1367. gen_code(op_asl,4,ap3,make_immed(ap1->scale));
  1368. make_legal(ap3,F_AREG | F_VOL,4);
  1369. }
  1370. else
  1371. make_legal(ap3,F_AREG,4);
  1372. ap1->preg = ap3->preg;
  1373. ap1->mode = am_indx;
  1374. }
  1375. if (ap2->preg == -1) {
  1376. ap3 = xalloc(sizeof(AMODE));
  1377. ap3->preg = ap2->sreg;
  1378. if (ap2->mode == am_baseindxdata) {
  1379. ap3->mode = F_DREG;
  1380. if (ap3->preg < cf_freedata)
  1381. ap3->tempflag = 1;
  1382. }
  1383. else {
  1384. ap3->mode = F_AREG;
  1385. if (ap3->preg < cf_freeaddress)
  1386. ap3->tempflag = 1;
  1387. }
  1388. if (ap2->scale) {
  1389. make_legal(ap3,F_DREG | F_VOL,4);
  1390. gen_code(op_asl,4,ap3,make_immed(ap2->scale));
  1391. make_legal(ap3,F_AREG | F_VOL,4);
  1392. }
  1393. else
  1394. make_legal(ap3,F_AREG,4);
  1395. ap2->preg = ap3->preg;
  1396. ap2->mode = am_indx;
  1397. }
  1398. goto tryagain;
  1399. }
  1400. break;
  1401. case am_baseindxdata:
  1402. switch (ap2->mode) {
  1403. case am_areg:
  1404. if (ap1->preg == -1) {
  1405. ap1->preg = ap2->preg;
  1406. return ap1;
  1407. }
  1408. freeop(ap1);
  1409. ap = temp_addr();
  1410. gen_lea(0,ap1,ap);
  1411. ap2->mode = am_baseindxaddr;
  1412. ap2->scale = 0;
  1413. ap2->offset = makenode(en_icon,0,0);
  1414. ap2->sreg = ap->preg;
  1415. return ap2;
  1416. case am_dreg:
  1417. if (ap1->preg == -1) {
  1418. ap = temp_addr();
  1419. gen_code(op_move,4,ap2,ap);
  1420. ap1->preg = ap->preg;
  1421. return ap1;
  1422. }
  1423. freeop(ap1);
  1424. ap = temp_addr();
  1425. gen_lea(0,ap1,ap);
  1426. ap->mode = am_baseindxdata;
  1427. ap->scale = 0;
  1428. ap->offset = makenode(en_icon,0,0);
  1429. ap->sreg = ap2->preg;
  1430. return ap;
  1431. case am_adirect:
  1432. if (prm_68020) {
  1433. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  1434. return ap1;
  1435. }
  1436. if (ap1->preg == -1) {
  1437. ap = temp_addr();
  1438. ap1->preg = ap->preg;
  1439. gen_lea(0,ap2,ap);
  1440. return ap1;
  1441. }
  1442. ap = temp_addr();
  1443. gen_lea(0,ap2,ap);
  1444. ap1->mode = am_baseindxaddr;
  1445. ap1->sreg = ap->preg;
  1446. ap1->scale = 0;
  1447. ap1->offset = makenode(en_icon,0,0);
  1448. return ap1;
  1449. case am_immed:
  1450. if (!prm_68020 && ap1->preg == -1) {
  1451. ap = temp_addr();
  1452. gen_code(op_move,4,ap2,ap);
  1453. ap1->preg = ap->preg;
  1454. return ap1;
  1455. }
  1456. if (prm_68020 || isambyte2(ap1,ap2)) {
  1457. if (ap1->offset->nodetype == am_immed)
  1458. ap1->offset->v.i += ap2->offset->v.i;
  1459. else
  1460. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  1461. return ap1;
  1462. }
  1463. freeop(ap1);
  1464. ap = temp_addr();
  1465. gen_lea(0,ap1,ap);
  1466. if ((!prm_largedata && (prm_rel || !prm_smalldata)) || prm_68020) {
  1467. ap->mode = am_indx;
  1468. ap->offset = ap2->offset;
  1469. return ap;
  1470. }
  1471. ap1 = temp_data();
  1472. ap1->mode = am_baseindxdata;
  1473. ap1->sreg = ap->preg;
  1474. ap1->scale = 0;
  1475. ap1->offset = makenode(en_icon,0,0);
  1476. return ap1;
  1477. case am_indx:
  1478. if (prm_68020 || isambyte2(ap1,ap2)) {
  1479. if (ap1->preg == -1) {
  1480. ap1->preg = ap2->preg;
  1481. if (ap2->offset->nodetype == am_immed && ap1->offset->nodetype == am_immed)
  1482. ap1->offset->v.i+= ap2->offset->v.i;
  1483. else
  1484. ap1->offset = makenode(en_add,ap1->offset, ap2->offset);
  1485. return ap1;
  1486. }
  1487. freeop(ap1);
  1488. ap = temp_addr();
  1489. gen_lea(0,ap1,ap);
  1490. ap->mode = am_baseindxaddr;
  1491. ap->sreg = ap2->preg;
  1492. ap->scale = 0;
  1493. ap->offset = ap2->offset;
  1494. return ap;
  1495. }
  1496. if (ap1->preg == -1) {
  1497. ap3 = xalloc(sizeof(AMODE));
  1498. ap3->preg = ap1->sreg;
  1499. if (ap1->mode == am_baseindxdata) {
  1500. ap3->mode = F_DREG;
  1501. if (ap3->preg < cf_freedata)
  1502. ap3->tempflag = 1;
  1503. }
  1504. else {
  1505. ap3->mode = F_AREG;
  1506. if (ap3->preg < cf_freeaddress)
  1507. ap3->tempflag = 1;
  1508. }
  1509. if (ap3->preg < cf_freedata)
  1510. ap3->tempflag = 1;
  1511. if (ap1->scale) {
  1512. make_legal(ap3,F_DREG | F_VOL,4);
  1513. gen_code(op_asl,4,ap3,make_immed(ap1->scale));
  1514. make_legal(ap3,F_AREG | F_VOL,4);
  1515. }
  1516. else
  1517. make_legal(ap3,F_AREG,4);
  1518. ap1->preg = ap3->preg;
  1519. ap1->mode = am_indx;
  1520. return ap1;
  1521. }
  1522. freeop(ap1);
  1523. ap = temp_addr();
  1524. gen_lea(0,ap1,ap);
  1525. ap1 = temp_data();
  1526. gen_code(op_move,4,ap,ap1);
  1527. freeop(ap2);
  1528. gen_lea(0,ap2,ap);
  1529. ap->mode = am_baseindxdata;
  1530. ap->sreg = ap1->preg;
  1531. ap->scale = 0;
  1532. ap->offset = makenode(en_icon,0,0);
  1533. return ap;
  1534. case am_ind:
  1535. if (ap1->preg == -1) {
  1536. ap1->preg = ap2->preg;
  1537. return ap1;
  1538. }
  1539. freeop(ap1);
  1540. ap = temp_addr();
  1541. gen_lea(0,ap1,ap);
  1542. ap->mode = am_baseindxaddr;
  1543. ap->sreg = ap2->preg;
  1544. ap->scale = 0;
  1545. ap->offset = ap1->offset;
  1546. return ap;
  1547. case am_baseindxaddr:
  1548. case am_baseindxdata:
  1549. if (prm_68020 || (ap1->preg != -1 && ap2->preg != -1)) {
  1550. freeop(ap1);
  1551. ap = temp_addr();
  1552. gen_lea(0,ap1,ap);
  1553. ap1 = temp_data();
  1554. gen_code(op_move,4,ap,ap1);
  1555. freeop(ap2);
  1556. gen_lea(0,ap2,ap);
  1557. ap->mode = am_baseindxdata;
  1558. ap->sreg = ap->preg;
  1559. ap->scale = 0;
  1560. ap->offset = makenode(en_icon,0,0);
  1561. return ap;
  1562. }
  1563. if (ap1->preg == -1) {
  1564. ap3 = xalloc(sizeof(AMODE));
  1565. ap3->preg = ap1->sreg;
  1566. if (ap1->mode == am_baseindxdata) {
  1567. ap3->mode = F_DREG;
  1568. if (ap3->preg < cf_freedata)
  1569. ap3->tempflag = 1;
  1570. }
  1571. else {
  1572. ap3->mode = F_AREG;
  1573. if (ap3->preg < cf_freeaddress)
  1574. ap3->tempflag = 1;
  1575. }
  1576. if (ap1->scale) {
  1577. make_legal(ap3,F_DREG | F_VOL,4);
  1578. gen_code(op_asl,4,ap3,make_immed(ap1->scale));
  1579. make_legal(ap3,F_AREG | F_VOL,4);
  1580. }
  1581. else
  1582. make_legal(ap3,F_AREG,4);
  1583. ap1->preg = ap3->preg;
  1584. ap1->mode = am_indx;
  1585. }
  1586. if (ap2->preg == -1) {
  1587. ap3 = xalloc(sizeof(AMODE));
  1588. ap3->preg = ap2->sreg;
  1589. if (ap2->mode == am_baseindxdata) {
  1590. ap3->mode = F_DREG;
  1591. if (ap3->preg < cf_freedata)
  1592. ap3->tempflag = 1;
  1593. }
  1594. else {
  1595. ap3->mode = F_AREG;
  1596. if (ap3->preg < cf_freeaddress)
  1597. ap3->tempflag = 1;
  1598. }
  1599. if (ap2->scale) {
  1600. make_legal(ap3,F_DREG | F_VOL,4);
  1601. gen_code(op_asl,4,ap3,make_immed(ap2->scale));
  1602. make_legal(ap3,F_AREG | F_VOL,4);
  1603. }
  1604. else
  1605. make_legal(ap3,F_AREG,4);
  1606. ap2->preg = ap3->preg;
  1607. ap2->mode = am_indx;
  1608. }
  1609. goto tryagain;
  1610. }
  1611. break;
  1612. }
  1613. DIAG("invalid index conversion");
  1614. }
  1615. AMODE    *gen_deref(ENODE *node, int flags,int size, int flag)
  1616. /*
  1617.  *      return the addressing mode of a dereferenced node.
  1618.  */
  1619. {       AMODE    *ap1,*ap2;
  1620.         int             siz1,psize;
  1621. psize = size;
  1622. if (psize < 0)
  1623. psize = - psize;
  1624.         switch( node->nodetype )        /* get load size */
  1625.                 {
  1626.                 case en_ub_ref:
  1627.                         siz1 = 1;
  1628.                         break;
  1629.                 case en_b_ref:
  1630.                         siz1 = -1;
  1631.                         break;
  1632.                 case en_uw_ref:
  1633.                         siz1 = 2;
  1634.                         break;
  1635.                 case en_w_ref:
  1636.                         siz1 = -2;
  1637.                         break;
  1638.                 case en_l_ref:
  1639. siz1 = -4;
  1640. break;
  1641. case en_add:
  1642. case en_ul_ref:
  1643.                         siz1 = 4;
  1644.                         break;
  1645. case en_floatref:
  1646. siz1 = 6;
  1647. break;
  1648. case en_doubleref:
  1649. siz1 = 8;
  1650. break;
  1651. case en_longdoubleref:
  1652. siz1 = 10;
  1653. break;
  1654. default:
  1655. siz1 = 4;
  1656.                 }
  1657.         if( node->v.p[0]->nodetype == en_add )
  1658.                 {
  1659.                 ap1 = gen_index(siz1,node->v.p[0]);
  1660.                 do_extend(ap1,siz1,size,flags);
  1661.                 make_legal(ap1,flags,psize);
  1662.                 return ap1;
  1663.                 }
  1664.         else if( node->v.p[0]->nodetype == en_autocon  || node->v.p[0]->nodetype == en_autoreg)
  1665.                 {
  1666.                 ap1 = xalloc(sizeof(AMODE));
  1667.                 ap1->mode = am_indx;
  1668. if (prm_linkreg && !currentfunc->intflag) {
  1669.                  ap1->preg = linkreg;
  1670.                  ap1->offset = makenode(en_icon,(char *)((SYM *)node->v.p[0]->v.p[0])->value.i,0);
  1671. }
  1672. else if (((SYM *)node->v.p[0]->v.p[0])->funcparm) {
  1673. if (prm_phiform || currentfunc->intflag) {
  1674.                  ap1->preg = linkreg;
  1675.                  ap1->offset = makenode(en_icon,(char *)((SYM *)node->v.p[0]->v.p[0])->value.i,0);
  1676. }
  1677. else {
  1678.                  ap1->preg = 7;
  1679.                  ap1->offset = makenode(en_icon,(char *)(((SYM *)node->v.p[0]->v.p[0])->value.i+framedepth+stackdepth),0);
  1680. }
  1681. }
  1682. else {
  1683.                  ap1->preg = 7;
  1684.                  ap1->offset = makenode(en_icon,(char *)(((SYM *)node->v.p[0]->v.p[0])->value.i+stackdepth+lc_maxauto),0);
  1685. }
  1686.                 do_extend(ap1,siz1,size,flags);
  1687.                 make_legal(ap1,flags,psize);
  1688.                 return ap1;
  1689.                 }
  1690.         else if( node->v.p[0]->nodetype == en_nacon)
  1691.                 {
  1692.                ap1 = xalloc(sizeof(AMODE));
  1693. if (prm_rel) {
  1694.                  ap1->preg = basereg;
  1695.                  ap1->offset = makenode(node->v.p[0]->nodetype,((SYM *)node->v.p[0]->v.p[0])->name,0);
  1696.         if (prm_largedata) {
  1697. ap2 = temp_addr();
  1698. ap1->mode = am_areg;
  1699. gen_code(op_move,4,ap1,ap2);
  1700. ap1->mode = am_immed;
  1701. gen_code(op_add,4,ap1,ap2);
  1702. ap1 = ap2;
  1703. ap1->mode = am_ind;
  1704. }
  1705. else {
  1706.                   ap1->mode = am_indx;
  1707. }
  1708. }
  1709. else {
  1710. ap1->mode = am_adirect;
  1711.                  ap1->offset = makenode(node->v.p[0]->nodetype,((SYM *)node->v.p[0]->v.p[0])->name,0);
  1712. if (prm_smalldata)
  1713. ap1->preg = 2;
  1714. else
  1715. ap1->preg = 4;
  1716. }
  1717.                 do_extend(ap1,siz1,size,flags);
  1718.                 make_legal(ap1,flags,psize);
  1719.                 return ap1;
  1720.                 }
  1721.         else if( node->v.p[0]->nodetype == en_nalabcon)
  1722.                 {
  1723.                ap1 = xalloc(sizeof(AMODE));
  1724. if (prm_rel) {
  1725.                  ap1->preg = basereg;
  1726.                  ap1->offset = makenode(node->v.p[0]->nodetype,(char *)node->v.p[0]->v.i,0);
  1727.         if (prm_largedata) {
  1728. ap2 = temp_addr();
  1729. ap1->mode = am_areg;
  1730. gen_code(op_move,4,ap1,ap2);
  1731. ap1->mode = am_immed;
  1732. gen_code(op_add,4,ap1,ap2);
  1733. ap1 = ap2;
  1734. ap1->mode = am_ind;
  1735. }
  1736. else {
  1737.                   ap1->mode = am_indx;
  1738. }
  1739. }
  1740. else {
  1741. ap1->mode = am_adirect;
  1742.                  ap1->offset = makenode(node->v.p[0]->nodetype,(char *)node->v.p[0]->v.i,0);
  1743. if (prm_smalldata)
  1744. ap1->preg = 2;
  1745. else
  1746. ap1->preg = 4;
  1747. }
  1748.                 do_extend(ap1,siz1,size,flags);
  1749.                 make_legal(ap1,flags,psize);
  1750.                 return ap1;
  1751.                 }
  1752.         else if( node->v.p[0]->nodetype == en_labcon || node->v.p[0]->nodetype == en_napccon)
  1753.                 {
  1754.                 ap1 = xalloc(sizeof(AMODE));
  1755. if (prm_rel)
  1756.                   ap1->mode = am_pcindx;
  1757. else {
  1758. ap1->mode = am_adirect;
  1759. if (prm_smallcode)
  1760. ap1->preg = 2;
  1761. else
  1762. ap1->preg = 4;
  1763. }
  1764. if (node->v.p[0]->nodetype == en_labcon)
  1765.                   ap1->offset = makenode(node->v.p[0]->nodetype,(char *)node->v.p[0]->v.i,0);
  1766. else
  1767.                   ap1->offset = makenode(node->v.p[0]->nodetype,((SYM *)node->v.p[0]->v.p[0])->name,0);
  1768.                 do_extend(ap1,siz1,size,flags);
  1769.                 make_legal(ap1,flags,psize);
  1770.                 return ap1;
  1771.                 }
  1772. else if (node->v.p[0]->nodetype == en_absacon) {
  1773. ap1 = xalloc(sizeof(AMODE));
  1774. ap1->mode = am_adirect;
  1775. ap1->preg = isshort(node->v.p[0]) ? 2 : 4;
  1776. ap1->offset = makenode(en_absacon,(char *)((SYM *)node->v.p[0]->v.p[0])->value.i,0);
  1777.                 do_extend(ap1,siz1,size,flags);
  1778.                 make_legal(ap1,flags,psize);
  1779.                 return ap1;
  1781. }
  1782. else if (node->v.p[0]->nodetype == en_regref) {
  1783.          ap1 = gen_expr(node->v.p[0],F_ALL,4);
  1784.           do_extend(ap1,siz1,size,flags);
  1785.           make_legal(ap1,flags,psize);
  1786. return ap1;
  1787. }
  1788. if (flag) {
  1789.          ap1 = gen_expr(node->v.p[0],F_AREG | F_DREG | F_IMMED,4); /* generate address */
  1790. if (ap1->mode == am_dreg)
  1791. return ap1;
  1792. }
  1793. else {
  1794.          ap1 = gen_expr(node->v.p[0],F_AREG | F_IMMED,4); /* generate address */
  1795. }
  1797. /* AINCDEC for example may return an indirect mode already */
  1798. if (ap1->mode == am_areg || ap1->mode == am_immed) {
  1799.          if( ap1->mode == am_areg )
  1800.                  {
  1801.                  ap1->mode = am_ind;
  1802.                  do_extend(ap1,siz1,size,flags);
  1803.                  make_legal(ap1,flags,psize);
  1804.                  return ap1;
  1805.                  }
  1806.          ap1->mode = am_direct;
  1807. }
  1808.         do_extend(ap1,siz1,size,flags);
  1809.         make_legal(ap1,flags,psize);
  1810.         return ap1;
  1811. }
  1813. AMODE    *gen_unary(ENODE *node,int flags,int size,int op, int fop)
  1814. /*
  1815.  *      generate code to evaluate a unary minus or complement.
  1816.  */
  1817. {       AMODE    *ap;
  1818.         ap = gen_expr(node->v.p[0],F_FREG | F_DREG | F_VOL,size);
  1819. if (ap->mode == am_freg) {
  1820.          gen_codef(fop,size,ap,0);
  1821. }
  1822. else {
  1823.          gen_code(op,size,ap,0);
  1824. }
  1825.         make_legal(ap,flags,size);
  1826.         return ap;
  1827. }
  1829. AMODE    *gen_binary(ENODE *node,int flags,int size,int op, int fop)
  1830. /*
  1831.  *      generate code to evaluate a binary node and return 
  1832.  *      the addressing mode of the result.
  1833.  */
  1834. {       AMODE    *ap1, *ap2;
  1835.         ap1 = gen_expr(node->v.p[0],F_VOL | F_DREG | F_AREG | F_FREG,size);
  1836. mark();
  1837.         ap2 = gen_expr(node->v.p[1],F_ALL,size);
  1838. if (size > 4)
  1839.          gen_codef(fop,size,ap2,ap1);
  1840. else
  1841.          gen_code(op,size,ap2,ap1);
  1842.         freeop(ap2);
  1843.         release();
  1844.         make_legal(ap1,flags,size);
  1845.         return ap1;
  1846. }
  1848. AMODE    *gen_xbin(ENODE *node,int flags,int size,int op, int fop)
  1849. /*
  1850.  *      generate code to evaluate a restricted binary node and return 
  1851.  *      the addressing mode of the result.
  1852.  */
  1853. {       AMODE    *ap1, *ap2;
  1854.         ap1 = gen_expr(node->v.p[0],F_VOL | F_DREG | F_FREG,size);
  1855. mark();
  1856.         ap2 = gen_expr(node->v.p[1],F_DREG| F_FREG, size);
  1857. if (size > 4)
  1858.          gen_codef(fop,size,ap2,ap1);
  1859. else
  1860.          gen_code(op,size,ap2,ap1);
  1861.         freeop(ap2);
  1862. release();
  1863.         make_legal(ap1,flags,size);
  1864.         return ap1;
  1865. }
  1866. AMODE    *gen_shift(ENODE *node, int flags, int size, int op)
  1867. /*
  1868.  *      generate code to evaluate a shift node and return the
  1869.  *      address mode of the result.
  1870.  */
  1871. {       AMODE    *ap1, *ap2;
  1872.         ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,size);
  1873. mark();
  1874.         ap2 = gen_expr(node->v.p[1],F_DREG | F_IMMED,size);
  1875. doshift(op,ap2,ap1,size);
  1876.         freeop(ap2);
  1877. release();
  1878.         make_legal(ap1,flags,size);
  1879.         return ap1;
  1880. }
  1882. AMODE    *gen_modiv(ENODE *node, int flags, int size, int op, int modflag)
  1883. /*
  1884.  *      generate code to evaluate a mod operator or a divide
  1885.  *      operator. these operations are done on only long
  1886.  *      divisors and word dividends so that the 68000 div
  1887.  *      instruction can be used.
  1888.  */
  1889. {       AMODE    *ap1, *ap2,*ap3;
  1890. int temp;
  1891. int sz1 = natural_size(node->v.p[0]);
  1892. int sz2 = natural_size(node->v.p[0]);
  1893. int psize;
  1895. if (sz1 < 0)  sz1 = - sz1;
  1896. if (sz2 < 0)  sz2 = - sz2;
  1897. psize = sz2 > sz1 ? sz2 : sz1;
  1898. if (psize < 2) psize = 2;
  1899. if (op == op_divs)  psize = -psize;
  1901. if (size > 4) {
  1902. ap1 = gen_expr(node->v.p[0],F_FREG | F_VOL,size);
  1903. mark();
  1904. ap2 = gen_expr(node->v.p[1],F_ALL&~F_AREG,size);
  1905. gen_codef(op_fdiv,size,ap2,ap1);
  1906. freeop(ap2);
  1907. release();
  1908. make_legal(ap1,flags,size);
  1909. return(ap1);
  1911. }
  1912. if (prm_68020 || psize ==2 || psize == -2) {
  1913. if (psize != 2 && psize != -2)
  1914. if (op == op_divs)
  1915. op = op_divsl;
  1916. else
  1917. op = op_divul;
  1918.          ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,psize == 2 ? 4 : -4);
  1919. mark();
  1920.          ap2 = gen_expr(node->v.p[1],F_ALL & ~F_AREG,psize);
  1921. if (psize !=2 && psize != -2) {
  1922. ap3 = temp_data();
  1923. temp = ap3->preg;
  1924. ap3->mode = am_divsl;
  1925.          if( modflag ) {
  1926. ap3->sreg = ap1->sreg;
  1927. }
  1928. else {
  1929. ap3->sreg = ap3->preg = ap1->sreg;
  1930. }
  1931. gen_code(op,psize,ap2,ap3);
  1932. ap3->mode = am_dreg;
  1933. ap3->preg = temp;
  1934. if (modflag)
  1935. gen_code(op_exg,0,ap1,ap3);
  1936.          freeop(ap3);
  1937. }
  1938. else {
  1939. gen_code(op,2,ap2,ap1);
  1940. if (modflag) {
  1941. gen_code(op_swap,2,ap1,0);
  1942. }
  1943. }
  1944. do_extend(ap1,psize,size,flags);
  1945.          make_legal(ap1,flags,size);
  1946.          freeop(ap2);
  1947.          release();
  1948.          return ap1;
  1950. }
  1951. flush_for_libcall();
  1952. if (op == op_divs) {
  1953.          ap1 = gen_expr(node->v.p[0],F_ALL,-4);
  1954. }
  1955. else {
  1956.          ap1 = gen_expr(node->v.p[0],F_ALL,4);
  1957. }
  1958. mark();
  1959. if (op == op_divs) {
  1960.          ap2 = gen_expr(node->v.p[1],F_ALL,-4);
  1961. }
  1962. else {
  1963.          ap2 = gen_expr(node->v.p[1],F_ALL,4);
  1964. }
  1965. gen_code(op_move,4,ap1,push);
  1966.         freeop(ap2);
  1967. gen_code(op_move,4,ap2,push);
  1969. freeop(ap1);
  1970. if (op == op_divs)
  1971. if (modflag) {
  1972. ap1 = call_library("__mods",8);
  1973. }
  1974. else {
  1975. ap1 = call_library("__divs",8);
  1976. }
  1977. else
  1978. if (modflag) {
  1979. ap1 = call_library("__modu",8);
  1980. }
  1981. else {
  1982. ap1 = call_library("__divu",8);
  1983. }
  1984. release();
  1985. make_legal(ap1,flags,size);
  1986.         return ap1;
  1987. }
  1989. void swap_nodes(ENODE *node)
  1990. /*
  1991.  *      exchange the two operands in a node.
  1992.  */
  1993. {       ENODE    *temp;
  1994.         temp = node->v.p[0];
  1995.         node->v.p[0] = node->v.p[1];
  1996.         node->v.p[1] = temp;
  1997. }
  1999. AMODE * gen_pdiv(ENODE *node, int flags, int size)
  2000. {
  2001. AMODE *ap1, *ap2;
  2002. ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,4);
  2003. mark();
  2004. ap2 = gen_expr(node->v.p[1],F_ALL,2);
  2005. gen_code(op_divs,2,ap2,ap1);
  2006. freeop(ap2);
  2007. release();
  2008. make_legal(ap1,flags,size);
  2009.         return ap1;
  2010. }
  2011. AMODE * gen_pmul(ENODE *node, int flags, int size)
  2012. {
  2013. AMODE *ap1, *ap2;
  2014. if (isintconst(node->v.p[0]->nodetype))
  2015. swap_nodes(node);
  2016. ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,4);
  2017. mark();
  2018. ap2 = gen_expr(node->v.p[1],F_ALL,4);
  2019. gen_code(op_muls,0,ap2,ap1);
  2020. freeop(ap2);
  2021. release();
  2022. make_legal(ap1,flags,size);
  2023.         return ap1;
  2024. }
  2025. AMODE    *gen_mul(ENODE *node, int flags, int size, int op)
  2026. /*
  2027.  *      generate code to evaluate a multiply node. both operands
  2028.  *      are treated as words and the result is long and is always
  2029.  *      in a register so that the 68000 mul instruction can be used.
  2030.  */
  2031. {       AMODE    *ap1, *ap2;
  2032. int sz1 = natural_size(node->v.p[0]);
  2033. int sz2 = natural_size(node->v.p[0]);
  2034. int psize;
  2036. if (sz1 < 0)  sz1 = - sz1;
  2037. if (sz2 < 0)  sz2 = - sz2;
  2038. psize = sz2 > sz1 ? sz2 : sz1;
  2039. if (psize < 2) psize = 2;
  2040. if (op == op_muls)  psize = -psize;
  2042. if (size > 4) {
  2043. ap1 = gen_expr(node->v.p[0],F_FREG | F_VOL,size);
  2044. mark();
  2045. ap2 = gen_expr(node->v.p[1],F_ALL&~F_AREG,size);
  2046. gen_codef(op_fmul,size,ap2,ap1);
  2047. freeop(ap2);
  2048. release();
  2049. make_legal(ap1,flags,size);
  2050. return(ap1);
  2052. }
  2053. if (prm_68020 || psize == -2 || psize == 2) {
  2054. if (isintconst(node->v.p[0]->nodetype))
  2055. swap_nodes(node);
  2056.          ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,psize);
  2057. mark();
  2058.          ap2 = gen_expr(node->v.p[1],F_ALL&~F_AREG,psize);
  2059. gen_code(op,psize,ap2,ap1);
  2060. freeop(ap2);
  2061. release();
  2062. do_extend(ap1,psize,size,flags);
  2063. make_legal(ap1,flags,size);
  2064.          return ap1;
  2065. }
  2066. flush_for_libcall();
  2067. if (isintconst(node->v.p[0]->nodetype))
  2068. swap_nodes(node);
  2069. if (op == op_muls) {
  2070.          ap1 = gen_expr(node->v.p[0],F_ALL,-4);
  2071. }
  2072. else {
  2073.          ap1 = gen_expr(node->v.p[0],F_ALL,4);
  2074. }
  2075. mark();
  2076. if (op == op_muls) {
  2077.          ap2 = gen_expr(node->v.p[1],F_ALL,-4);
  2078. }
  2079. else {
  2080.          ap2 = gen_expr(node->v.p[1],F_ALL,4);
  2081. }
  2082. gen_code(op_move,4,ap1,push);
  2083.         freeop(ap2);
  2084. gen_code(op_move,4,ap2,push);
  2085. freeop(ap1);
  2086. if (op == op_muls) {
  2087. ap1 = call_library("__muls",8);
  2088. }
  2089. else {
  2090. ap1 = call_library("__mulu",8);
  2091. }
  2092.         release();
  2093. make_legal(ap1,flags,size);
  2094.         return ap1;
  2095. }
  2097. AMODE    *gen_hook(ENODE *node, int flags, int size)
  2098. /*
  2099.  *      generate code to evaluate a condition operator node (?:)
  2100.  */
  2101. {       AMODE    *ap1, *ap2;
  2102.         int             false_label, end_label;
  2103.         false_label = nextlabel++;
  2104.         end_label = nextlabel++;
  2105.         flags = (flags & (F_AREG | F_DREG)) | F_VOL;
  2106.         falsejp(node->v.p[0],false_label);
  2107.         node = node->v.p[1];
  2108.         ap1 = gen_expr(node->v.p[0],flags,size);
  2109.         freeop(ap1);
  2110.         gen_code(op_bra,0,make_label(end_label),0);
  2111.         gen_label(false_label);
  2112.         ap2 = gen_expr(node->v.p[1],flags,size);
  2113.         if( !equal_address(ap1,ap2) )
  2114.                 {
  2115.                 freeop(ap2);
  2116.                 if( ap1->mode == am_dreg )
  2117.                         temp_data();
  2118.                 else
  2119.                         temp_addr();
  2120.                 gen_code(op_move,size,ap2,ap1);
  2121.                 }
  2122.         gen_label(end_label);
  2123.         return ap1;
  2124. }
  2126. AMODE    *gen_asadd(ENODE *node, int flags, int size, int op, int fop)
  2127. /*
  2128.  *      generate a plus equal or a minus equal node.
  2129.  */
  2130. {       AMODE    *ap1, *ap2, *ap3;
  2131.         int             ssize,rsize;
  2132.         ssize = natural_size(node->v.p[0]);
  2133.         rsize = natural_size(node->v.p[1]);
  2134. if (ssize > 4) {
  2135. ap1 = gen_expr(node->v.p[0],F_ALL,ssize);
  2136. ap3 = xalloc(sizeof(AMODE));
  2137. ap3->mode = ap1->mode;
  2138. ap3->preg = ap1->preg;
  2139. ap3->sreg = ap1->sreg;
  2140. ap3->offset = ap1->offset;
  2141. make_legal(ap1,F_FREG,ssize);
  2142. mark();
  2143. ap2 = gen_expr(node->v.p[1],F_ALL,size);
  2144. gen_codef(fop,ssize,ap2,ap1);
  2145. make_legal(ap1,flags,size);
  2146. if (ap3->mode != am_freg)
  2147. gen_codef(op_fmove,ssize,ap1,ap3);
  2148. freeop(ap2);
  2149. release();
  2150. return(ap1);
  2152. }
  2153.         if (chksize( size , rsize ))
  2154.                 rsize = size;
  2155.         ap1 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,ssize);
  2156. mark();
  2157. if (node->v.p[0]->nodetype == en_bits) {
  2158. ap3= get_bitval(ap1,node->v.p[0],ssize);
  2159. }
  2160.         ap2 = gen_expr(node->v.p[1],F_DREG | F_AREG | F_FREG | F_IMMED,rsize);
  2161. if (ssize > 4)
  2162.          gen_codef(fop,ssize,ap2,ap1);
  2163. else 
  2164. if (node->v.p[0]->nodetype == en_bits) {
  2165. gen_code(op,ssize,ap2,ap3);
  2166. bit_move(ap3,ap1,node->v.p[0],flags, ssize,rsize);
  2167. freeop(ap3);
  2168. }
  2169. else
  2170.          gen_code(op,ssize,ap2,ap1);
  2171.        freeop(ap2);
  2172. release();
  2173. if (flags & F_NOVALUE)
  2174. freeop(ap1);
  2175. else {
  2176. if (node->v.p[0]->nodetype == en_bits) {
  2177.           do_extend(ap3,ssize,size,0);
  2178.           make_legal(ap3,flags,size);
  2179.           return ap3;
  2180.        }
  2181.        do_extend(ap1,ssize,size,0);
  2182.         make_legal(ap1,flags,size);
  2183. }
  2184.         return ap1;
  2185. }
  2187. AMODE    *gen_aslogic(ENODE *node, int flags, int size, int op)
  2188. /*
  2189.  *      generate a and equal or a or equal node.
  2190.  */
  2191. {       AMODE    *ap1, *ap2, *ap3;
  2192.         int             ssize,rsize;
  2193.         ssize = natural_size(node->v.p[0]);
  2194.         rsize = natural_size(node->v.p[1]);
  2195.         if (chksize( size , rsize ))
  2196.                 rsize = size;
  2197.         ap1 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,ssize);
  2198. mark();
  2199.         ap2 = gen_expr(node->v.p[1],F_DREG | F_IMMED,rsize);
  2200. if (node->v.p[0]->nodetype == en_bits) {
  2201. if (ap2->mode == am_immed) {
  2202. ap2->offset->v.i &= bittab[node->v.p[0]->bits-1];
  2203. ap2->offset->v.i <<= node->v.p[0]->startbit;
  2204. gen_code(op,ssize,ap2,ap1);
  2205. }
  2206. else {
  2207.   gen_code(op_and,ssize,make_immed(bittab[node->v.p[0]->bits-1]),ap2);
  2208. if (node->v.p[0]->startbit)
  2209.    gen_code(op_asl,ssize,make_immed(node->v.p[0]->startbit),ap2);
  2210. gen_code(op,ssize,ap2,ap1);
  2211. if (!(flags & F_NOVALUE)) {
  2212. freeop(ap2);
  2213. if (!(ap1->mode == am_dreg && ap1->preg < cf_freedata)) {
  2214. freeop(ap1);
  2215. ap2 = temp_data();
  2216. gen_code(op_move,ssize,ap1,ap2);
  2217. ap1 = ap2;
  2218. }
  2219. if (node->v.p[0]->startbit)
  2220.    gen_code(op_asr,ssize,make_immed(node->v.p[0]->startbit),ap1);
  2221.    gen_code(op_and,ssize,make_immed(bittab[node->v.p[0]->bits-1]),ap1);
  2222. }
  2223. }
  2224. }
  2225. else
  2226.          if( ap1->mode != am_areg )
  2227.                  gen_code(op,ssize,ap2,ap1);
  2228.         else
  2229.                  {
  2230.                  ap3 = temp_data();
  2231.                  gen_code(op_move,4,ap1,ap3);
  2232.                  gen_code(op,size,ap2,ap3);
  2233.                  gen_code(op_move,size,ap3,ap1);
  2234.                  freeop(ap3);
  2235.                  }
  2236.         freeop(ap2);
  2237. release();
  2238. if (flags & F_NOVALUE)
  2239. freeop(ap1);
  2240. else {
  2241.          do_extend(ap1,ssize,size,0);
  2242.          make_legal(ap1,flags,size);
  2243. }
  2244.         return ap1;
  2245. }
  2247. AMODE *gen_asshift(ENODE *node, int flags, int size, int op)
  2248. /*
  2249.  *      generate shift equals operators.
  2250.  */
  2251. {       AMODE    *ap1, *ap2, *ap3,*ap4;
  2252.         int ssize = natural_size(node->v.p[0]);
  2253.         int rsize = natural_size(node->v.p[1]);
  2254.         if (chksize( size , rsize ))
  2255.                 rsize = size;
  2256.         ap1 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,ssize);
  2257. mark();
  2258. if (node->v.p[0]->nodetype == en_bits)
  2259. ap4 = get_bitval(ap1,node->v.p[0],ssize);
  2260. else
  2261. ap4 = ap1;
  2262.         if( ap4->mode != am_dreg )
  2263.                 {
  2264.                 ap3 = temp_data();
  2265. ap3->tempflag = TRUE;
  2266.                 gen_code(op_move,ssize,ap4,ap3);
  2267.                 }
  2268.         else
  2269.                 ap3 = ap4;
  2270.         ap2 = gen_expr(node->v.p[1],F_DREG | F_IMMED,rsize);
  2271. doshift(op,ap2,ap3,size);
  2272. if (node->v.p[0]->nodetype == en_bits) {
  2273.   bit_move(ap3,ap1,node->v.p[0],flags,ssize,ssize);
  2274.         } else if( ap3 != ap1 )
  2275.                 {
  2276.                 gen_code(op_move,ssize,ap3,ap1);
  2277.                 }
  2278. freeop(ap2);
  2279. release();
  2280. if (ap4 != ap1)
  2281. freeop(ap4);
  2282. if (flags & F_NOVALUE)
  2283. freeop(ap2);
  2284. else {
  2285.        do_extend(ap3,ssize,size,0);
  2286.          make_legal(ap3,flags,size);
  2287. }
  2288.         return ap3;
  2289. }
  2291. AMODE    *gen_asmul(ENODE *node, int flags, int size,int op)
  2292. /*
  2293.  *      generate a *= node.
  2294.  */
  2295. {       AMODE    *ap1, *ap2, *ap3, *ap4;
  2296.         int             siz1;
  2297. int sz1 = natural_size(node->v.p[0]);
  2298. int sz2 = natural_size(node->v.p[0]);
  2299. int psize;
  2301. if (sz1 < 0)  sz1 = - sz1;
  2302. if (sz2 < 0)  sz2 = - sz2;
  2303. psize = sz2 > sz1 ? sz2 : sz1;
  2304. if (psize < 2) psize = 2;
  2305. if (op == op_muls)  psize = -psize;
  2306.         siz1 = natural_size(node->v.p[0]);
  2307. if (siz1 > 4) {
  2308. ap1 = gen_expr(node->v.p[0],F_ALL&~F_AREG,siz1);
  2309. ap3 = xalloc(sizeof(AMODE));
  2310. ap3->mode = ap1->mode;
  2311. ap3->preg = ap1->preg;
  2312. ap3->sreg = ap1->sreg;
  2313. ap3->offset = ap1->offset;
  2314. make_legal(ap1,F_FREG,siz1);
  2315. mark();
  2316. ap2 = gen_expr(node->v.p[1],F_ALL&~F_AREG,siz1);
  2317. gen_codef(op_fmul,siz1,ap2,ap1);
  2318. make_legal(ap1,flags,size);
  2319. if (ap3->mode != am_freg)
  2320. gen_codef(op_fmove,siz1,ap1,ap3);
  2321. freeop(ap2);
  2322. release();
  2323. return(ap1);
  2325. }
  2326. if (prm_68020 || psize == 2 || psize == -2) {
  2327.          ap1 = gen_expr(node->v.p[1],F_DREG | F_VOL,psize);
  2328. ap4 = xalloc(sizeof(AMODE));
  2329.          ap2 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,0);
  2330. ap4->mode = ap2->mode;
  2331. ap4->preg = ap2->preg;
  2332. ap4->sreg = ap2->sreg;
  2333. ap4->tempflag = ap2->tempflag;
  2334. ap4->offset = ap2->offset;
  2335. if (node->v.p[0]->nodetype == en_bits)
  2336. ap2 = get_bitval(ap2,node->v.p[0],psize);
  2337. do_extend(ap2,siz1, psize,F_ALL);
  2338.          gen_code(op,psize,ap2,ap1);
  2339. if (node->v.p[0]->nodetype == en_bits) 
  2340. bit_move(ap1,ap4,node->v.p[0],flags,siz1,psize);
  2341. else 
  2342.          gen_code(op_move,siz1,ap1,ap4);
  2343. if (flags & F_NOVALUE)
  2344. freeop(ap1);
  2345. else {
  2346.         do_extend(ap1,psize,size,flags);
  2347.           make_legal(ap1,flags,size);
  2348. }
  2349.          freeop(ap2);
  2350. return(ap1);
  2351. }
  2352. flush_for_libcall();
  2354. if (op == op_muls) {
  2355.          ap1 = gen_expr(node->v.p[1],F_ALL,-4);
  2356. }
  2357. else {
  2358.          ap1 = gen_expr(node->v.p[1],F_ALL,4);
  2359. }
  2360. ap4 = xalloc(sizeof(AMODE));
  2361.         ap2 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,siz1);
  2362. ap4->mode = ap2->mode;
  2363. ap4->preg = ap2->preg;
  2364. ap4->sreg = ap2->sreg;
  2365. ap4->tempflag = ap2->tempflag;
  2366. ap4->offset = ap2->offset;
  2367. if (node->v.p[0]->nodetype == en_bits)
  2368. ap2 = get_bitval(ap2,node->v.p[0],siz1);
  2370. if (op == op_muls) {
  2371. do_extend(ap2,siz1, - 4,F_ALL);
  2372. }
  2373. else {
  2374. do_extend(ap2,siz1, 4,F_ALL);
  2375. }
  2376. gen_code(op_move,4,ap2,push);
  2377. gen_code(op_move,4,ap1,push);
  2378.         freeop(ap2);
  2379. freeop(ap1);
  2380. if (op == op_muls) {
  2381. ap1 = call_library("__muls",8);
  2382. }
  2383. else {
  2384. ap1 = call_library("__mulu",8);
  2385. }
  2386. if (node->v.p[0]->nodetype == en_bits)
  2387. bit_move(ap1,ap4,node->v.p[0],flags,siz1,size);
  2388. else
  2389.          gen_code(op_move,siz1,ap1,ap4);
  2390. freeop(ap4);
  2391. if (flags & F_NOVALUE)
  2392. freeop(ap1);
  2393. else {
  2394.        do_extend(ap1,siz1,size,0);
  2395.          make_legal(ap1,flags,size);
  2396. }
  2397.         return ap1;
  2398. }
  2400. AMODE    *gen_asmodiv(ENODE *node, int flags, int size, int op, int modflag)
  2401. /*
  2402.  *      generate /= and %= nodes.
  2403.  */
  2404. {       AMODE    *ap1, *ap2, *ap3 = 0, *ap4,*ap5;
  2405.         int             siz1,temp;
  2406. int sz1 = natural_size(node->v.p[0]);
  2407. int sz2 = natural_size(node->v.p[0]);
  2408. int psize;
  2410. if (sz1 < 0)  sz1 = - sz1;
  2411. if (sz2 < 0)  sz2 = - sz2;
  2412. psize = sz2 > sz1 ? sz2 : sz1;
  2413. if (psize < 2) psize = 2;
  2414. if (op == op_muls)  psize = -psize;
  2415.         siz1 = natural_size(node->v.p[0]);
  2416. if (siz1 > 4) {
  2417. ap1 = gen_expr(node->v.p[0],F_ALL&~F_AREG,siz1);
  2418. ap3 = xalloc(sizeof(AMODE));
  2419. ap3->mode = ap1->mode;
  2420. ap3->preg = ap1->preg;
  2421. ap3->sreg = ap1->sreg;
  2422. ap3->offset = ap1->offset;
  2423. make_legal(ap1,F_FREG,siz1);
  2424. mark();
  2425. ap2 = gen_expr(node->v.p[1],F_ALL&~F_AREG,siz1);
  2426. gen_codef(op_fdiv,siz1,ap2,ap1);
  2427. make_legal(ap1,flags,size);
  2428. if (ap3->mode != am_freg)
  2429. gen_codef(op_fmove,siz1,ap1,ap3);
  2430. freeop(ap2);
  2431. release();
  2432. return(ap1);
  2433. }
  2434. if (prm_68020 || psize == 2 || psize == -2) {
  2435. if (psize !=2 && psize != -2)
  2436. if (op == op_divs) 
  2437. op = op_divsl;
  2438. else
  2439. op = op_divul;
  2440.          ap1 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,0);
  2441. ap5 = xalloc(sizeof(AMODE));
  2442. ap5->mode = ap1->mode;
  2443. ap5->preg = ap1->preg;
  2444. ap5->sreg = ap1->sreg;
  2445. ap5->offset = ap1->offset;
  2446. if (node->v.p[0]->nodetype == en_bits)
  2447. ap1 = get_bitval(ap1,node->v.p[0],siz1);
  2449. do_extend(ap1,siz1, psize == 2 ? 4 : -4,F_DREG | F_VOL);
  2450. make_legal(ap1,F_DREG | F_VOL,psize == 2 ? 4 : -4);
  2451. mark();
  2452.         ap3 = gen_expr(node->v.p[1],F_ALL & ~F_AREG,psize);
  2453. if (psize != 2 && psize != -2) {
  2454. ap4 = temp_data();
  2455. ap4->tempflag = TRUE;
  2456. temp = ap4->preg;
  2457.           if( modflag ) {
  2458. gen_code(op_move,4,ap1,ap4);
  2459. ap4->sreg = ap1->preg;
  2460. }
  2461. else {
  2462. ap4->sreg = ap4->preg = ap1->preg;
  2463. }
  2464. ap4->mode = am_divsl;
  2465. gen_code(op,psize,ap3,ap4);
  2466. ap4->mode = am_dreg;
  2467. ap4->preg = temp;
  2468. freeop(ap4);
  2469.           freeop(ap3);
  2470.          release();
  2471. }
  2472. else {
  2473. gen_code(op,psize,ap3,ap1);
  2474. if (modflag) {
  2475. gen_code(op_swap,2,ap1,0);
  2476. }
  2477. freeop(ap3);
  2478. }
  2479. if (node->v.p[0]->nodetype == en_bits)
  2480. bit_move(ap1,ap5,node->v.p[0],flags,psize,size);
  2481. else
  2482.           gen_code(op_move,siz1,ap1,ap5);
  2483. if (flags & F_NOVALUE)
  2484. freeop(ap1);
  2485. else {
  2486.        do_extend(ap1,psize,size,0);
  2487.          make_legal(ap1,flags,size);
  2488. }
  2489.          freeop(ap2);
  2490.         return ap1;
  2491. }
  2492. flush_for_libcall();
  2493. if (op == op_divs) {
  2494.          ap1 = gen_expr(node->v.p[1],F_ALL,-4);
  2495. }
  2496. else {
  2497.          ap1 = gen_expr(node->v.p[1],F_ALL,4);
  2498. }
  2499. ap4 = xalloc(sizeof(AMODE));
  2500.         ap2 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,siz1);
  2501. ap4->mode = ap2->mode;
  2502. ap4->preg = ap2->preg;
  2503. ap4->sreg = ap2->sreg;
  2504. ap4->tempflag = ap2->tempflag;
  2505. ap4->offset = ap2->offset;
  2506. if (node->v.p[0]->nodetype == en_bits)
  2507. ap2 = get_bitval(ap2,node->v.p[0],siz1);
  2509. if (op == op_divs) {
  2510. do_extend(ap2,siz1, - 4,F_ALL);
  2511. }
  2512. else {
  2513. do_extend(ap2,siz1, 4,F_ALL);
  2514. }
  2515. gen_code(op_move,4,ap2,push);
  2516. gen_code(op_move,4,ap1,push);
  2517.         freeop(ap2);
  2518. freeop(ap1);
  2519. if (modflag)
  2520. if (op == op_divs)
  2521. ap1=call_library("__mods",8);
  2522. else
  2523. ap1=call_library("__modu",8);
  2524. else
  2525. if (op == op_divs)
  2526. ap1=call_library("__divs",8);
  2527. else
  2528. ap1=call_library("__divu",8);
  2529. make_legal(ap1,flags,size);
  2530. if (node->v.p[0]->nodetype == en_bits)
  2531. bit_move(ap1,ap4,node->v.p[0],flags,siz1,size);
  2532. else
  2533.          gen_code(op_move,siz1,ap1,ap4);
  2534. if (flags & F_NOVALUE)
  2535. freeop(ap1);
  2536. else {
  2537.       do_extend(ap1,siz1,size,0);
  2538.         make_legal(ap1,flags,size);
  2539. }
  2540. freeop(ap4);
  2541.         return ap1;
  2542. }
  2543. AMODE *gen_moveblock(ENODE *node, int flags, int size)
  2544. {
  2545. AMODE *ap1, *ap2, *ap3;
  2546. int lbl;
  2547. long v,tp,sz;
  2548. if (!(sz=node->size))
  2549. return(0);
  2550. if (sz & 1) {
  2551. tp = 1;
  2552. }
  2553. else if (sz & 2) {
  2554. tp = 2;
  2555. }
  2556. else {
  2557. tp = 4;
  2558. }
  2559. v = sz/tp;
  2560. if (v < 65536)
  2561. v--;
  2562. lbl = nextlabel++;
  2563. ap2 = gen_expr(node->v.p[0], F_AREG | F_VOL, 4);
  2564. mark();
  2565. ap3 = gen_expr(node->v.p[1], F_AREG | F_VOL,4);
  2566. ap1 = temp_data();
  2567. ap2->mode = am_ainc;
  2568. ap3->mode = am_ainc;
  2569. gen_code(op_move,v < 65536 ? 2 : 4,make_immed(v),ap1);
  2570. gen_label(lbl);
  2571. gen_code(op_move,tp,ap3,ap2);
  2572. if (v < 65536) 
  2573. gen_code(op_dbra,0,ap1,make_label(lbl));
  2574. else {
  2575. gen_code(op_sub,4,make_immed(1),ap1);
  2576. gen_code(op_bne,0,make_label(lbl),0);
  2577. }
  2578. freeop(ap3);
  2579. freeop(ap1);
  2580. freeop(ap2);
  2581. return(ap2);
  2582. release();
  2583. }
  2584. int count_regs(AMODE *ap1, AMODE *ap2)
  2585. {
  2586. int r = 0;
  2587. switch(ap1->mode) {
  2588. case am_baseindxaddr:
  2589. if (ap1->sreg < cf_freeaddress && ap1->sreg != -1)
  2590. r++;
  2591. case am_baseindxdata:
  2592. case am_ind:
  2593. case am_indx:
  2594. case am_areg:
  2595. if (ap1->preg < cf_freeaddress && ap1->preg != -1)
  2596. r++;
  2597. break;
  2598. }
  2599. switch(ap2->mode) {
  2600. case am_baseindxaddr:
  2601. if (ap2->sreg < cf_freeaddress && ap2->sreg != -1)
  2602. r++;
  2603. case am_baseindxdata:
  2604. case am_ind:
  2605. case am_indx:
  2606. case am_areg:
  2607. if (ap2->preg < cf_freeaddress && ap2->preg != -1)
  2608. r++;
  2609. break;
  2610. }
  2611. return r;
  2612. }
  2613. AMODE    *gen_assign(ENODE *node, int flags, int size)
  2614. /*
  2615.  *      generate code for an assignment node. if the size of the
  2616.  *      assignment destination is larger than the size passed then
  2617.  *      everything below this node will be evaluated with the
  2618.  *      assignment size.
  2619.  */
  2620. {       AMODE    *ap1, *ap2,*ap3;
  2621.         int             ssize,rsize;
  2622. int q = node->v.p[0]->nodetype;
  2623. rsize = natural_size(node->v.p[1]);
  2624. if (q == en_bits)
  2625. q = node->v.p[0]->v.p[0]->nodetype;
  2626.         switch( q )        
  2627.                 {
  2628. case en_bits:
  2629. ssize = natural_size(node->v.p[0]);
  2630. break;
  2631.                 case en_ub_ref:
  2632. case en_cub:
  2633.                         ssize = 1;
  2634.                         break;
  2635.                 case en_b_ref:
  2636. case en_cb:
  2637.                         ssize = -1;
  2638.                         break;
  2639.                 case en_uw_ref:
  2640. case en_cuw:
  2641.                         ssize = 2;
  2642.                         break;
  2643.                 case en_w_ref:
  2644. case en_cw:
  2645.                         ssize = -2;
  2646.                         break;
  2647.                 case en_l_ref:
  2648. case en_cl:
  2649. ssize = -4;
  2650. break;
  2651.                 case en_ul_ref:
  2652. case en_cul:
  2653. case en_cp:
  2654.                         ssize = 4;
  2655.                         break;
  2656.                 case en_tempref:
  2657.                 case en_regref:
  2658. ssize = node->v.p[0]->v.i >> 8;
  2659. break;
  2660. case en_floatref:
  2661. case en_cf:
  2662. ssize = 6;
  2663. break;
  2664. case en_doubleref:
  2665. case en_cd:
  2666. ssize = 8;
  2667. break;
  2668. case en_longdoubleref:
  2669. case en_cld:
  2670. ssize = 10;
  2671. break;
  2672.                 }
  2673.         if (chksize( size , rsize ))
  2674.                 rsize = size;
  2675.         ap2 = gen_expr(node->v.p[1],F_DREG | F_FREG | F_IMMED,rsize);
  2676. do_extend(ap2,rsize,ssize,flags);
  2677. mark();
  2678.         ap1 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,ssize);
  2679. if (ssize > 4) {
  2680. gen_codef(op_fmove,ssize,ap2,ap1);
  2681. }
  2682. else {
  2683. if (node->v.p[0]->nodetype ==en_bits)
  2684. bit_move(ap2,ap1,node->v.p[0],flags,ssize,size);
  2685. else
  2686.          gen_code(op_move,ssize,ap2,ap1);
  2687. }
  2688. freeop(ap1);
  2689. release();
  2690. if (flags & F_NOVALUE) 
  2691. freeop(ap2);
  2692. else {
  2693. do_extend(ap2,ssize,size,flags);
  2694. make_legal(ap2,flags,size);
  2695. }
  2696.         return ap2;
  2697. }
  2698. AMODE    *gen_refassign(ENODE *node, int flags, int size)
  2699. /*
  2700.  *      generate code for an assignment node. if the size of the
  2701.  *      assignment destination is larger than the size passed then
  2702.  *      everything below this node will be evaluated with the
  2703.  *      assignment size.
  2704.  */
  2705. {       AMODE    *ap1, *ap2,*ap4;
  2706.         int             ssize,rsize;
  2707. int q = node->v.p[0]->nodetype;
  2708. rsize = natural_size(node->v.p[1]);
  2709. if (q == en_bits)
  2710. q = node->v.p[0]->v.p[0]->nodetype;
  2711.         switch( q )        
  2712.                 {
  2713. case en_bits:
  2714. ssize = natural_size(node->v.p[0]);
  2715. break;
  2716.                 case en_ub_ref:
  2717. case en_cub:
  2718.                         ssize = 1;
  2719.                         break;
  2720.                 case en_b_ref:
  2721. case en_cb:
  2722.                         ssize = -1;
  2723.                         break;
  2724.                 case en_uw_ref:
  2725. case en_cuw:
  2726.                         ssize = 2;
  2727.                         break;
  2728.                 case en_w_ref:
  2729. case en_cw:
  2730.                         ssize = -2;
  2731.                         break;
  2732.                 case en_l_ref:
  2733. case en_cl:
  2734. ssize = -4;
  2735. break;
  2736.                 case en_ul_ref:
  2737. case en_cul:
  2738. case en_cp:
  2739.                         ssize = 4;
  2740.                         break;
  2741.                 case en_tempref:
  2742.                 case en_regref:
  2743. ssize = node->v.p[0]->v.i >> 8;
  2744. break;
  2745. case en_floatref:
  2746. case en_cf:
  2747. ssize = 6;
  2748. break;
  2749. case en_doubleref:
  2750. case en_cd:
  2751. ssize = 8;
  2752. break;
  2753. case en_longdoubleref:
  2754. case en_cld:
  2755. ssize = 10;
  2756. break;
  2757.                 }
  2758.         if (chksize( size , rsize ))
  2759.                 rsize = size;
  2760.         ap1 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,ssize);
  2761. mark();
  2762.         ap2 = gen_expr(node->v.p[1],F_ALL,rsize);
  2763. ap4 = xalloc(sizeof(AMODE));
  2764. ap4->mode = am_ind;
  2765. ap4->preg = ap1->preg;
  2766. make_legal(ap2,flags,ssize);
  2767. if (ssize > 4) {
  2768. if (ap1->mode != am_freg && ap2->mode != am_freg) {
  2769. AMODE *ap3 = temp_float();
  2770. gen_codef(op_fmove,ssize,ap2,ap3);
  2771.          gen_codef(op_fmove,ssize,ap3,ap4);
  2772. freeop(ap1);
  2773. freeop(ap2);
  2774. return(ap3);
  2775. }
  2776. else 
  2777. gen_codef(op_fmove,ssize,ap2,ap4);
  2778. }
  2779. else
  2780. if (node->v.p[0]->nodetype ==en_bits)
  2781. bit_move(ap2,ap4,node->v.p[0],flags,ssize,size);
  2782. else
  2783.          gen_code(op_move,ssize,ap2,ap4);
  2784. freeop(ap2);
  2785. release();
  2786. do_extend(ap1,ssize,size,flags);
  2787. make_legal(ap1,flags,size);
  2788.         return ap1;
  2789. }
  2791. AMODE    *gen_aincdec(ENODE *node, int flags, int size, int op)
  2792. /*
  2793.  *      generate an auto increment or decrement node. op should be
  2794.  *      either op_add (for increment) or op_sub (for decrement).
  2795.  */
  2796. {       AMODE    *ap1, *ap2, *ap3;
  2797.         int             siz1;
  2798.         siz1 = natural_size(node->v.p[0]);
  2799.         if( flags & F_NOVALUE )         /* dont need result */
  2800.                 {
  2801.          ap1 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,siz1);
  2802. if (node->v.p[0]->nodetype == en_bits) {
  2803. ap2 = get_bitval(ap1,node->v.p[0],siz1);
  2804. gen_code(op,siz1,make_immed(1),ap2);
  2805. bit_move(ap2,ap1,node->v.p[0],flags,siz1,size);
  2806. }
  2807. else {
  2808.                  gen_code(op,siz1,make_immed((long)node->v.p[1]),ap1);
  2809. }
  2810.                 freeop(ap1);
  2812.                 return ap1;
  2813.                 }
  2814. if (flags & F_DREG)
  2815. ap3 = temp_data();
  2816. else if (flags & F_AREG)
  2817. ap3 = temp_addr();
  2818. ap3->tempflag = 1;
  2819.         ap1 = gen_expr(node->v.p[0],F_ALL | F_NOBIT,siz1);
  2820. if (node->v.p[0]->nodetype == en_bits) {
  2821. ap2 = get_bitval(ap1,node->v.p[0],siz1);
  2822. gen_code(op_move,siz1,ap2,ap3);
  2823. gen_code(op,siz1,make_immed(1),ap2);
  2824. bit_move(ap2,ap1,node->v.p[0],flags,siz1,size);
  2825.          do_extend(ap3,siz1,size,0);
  2826. make_legal(ap3,flags,size);
  2827. freeop(ap2);
  2828. }
  2829. else {
  2830. if (siz1 <=4 && ap1->mode == am_areg && ap1->preg >= cf_freeaddress && op == op_add) {
  2831. if (op == op_add) {
  2832. freeop(ap3);
  2833. ap3 = ap1;
  2834. ap3->mode = am_ainc;
  2835. flags |= F_INDX;
  2836. }
  2837. }
  2838. else {
  2839. gen_code(op_move,siz1,ap1,ap3);
  2840.              gen_code(op,siz1,make_immed((long)node->v.p[1]),ap1);
  2841. freeop(ap1);
  2842. }
  2843. }
  2844.         do_extend(ap3,siz1,size,0);
  2845. make_legal(ap3,flags,size);
  2846.         return ap3;
  2847. }
  2849. int push_param(ENODE *ep,int size)
  2850. /*
  2851.  *      push the operand expression onto the stack.
  2852.  */
  2853. {       AMODE    *ap,*ap1;
  2854. int rv;
  2855. switch (ep->nodetype) {
  2856.                 case en_napccon:
  2857. ep->v.p[0] = ((SYM *)ep->v.p[0])->name;
  2858.                 case en_labcon:
  2859.                         ap = xalloc(sizeof(AMODE));
  2860. if (prm_rel)
  2861.                   ap->mode = am_pcindx;
  2862. else {
  2863. ap->mode = am_adirect;
  2864. if (prm_smallcode)
  2865. ap->preg = 2;
  2866. else
  2867. ap->preg = 4;
  2868. }
  2869.                         ap->offset = ep;     /* use as constant node */
  2870.                         gen_code(op_pea,0,ap,0);
  2871. rv = 4;
  2872. break;
  2873. case en_absacon:
  2874.                         ap = xalloc(sizeof(AMODE));
  2875.                         ap->mode = am_adirect;
  2876. ep->v.i = ((SYM *)ep->v.p[0])->value.i;
  2877. ap->preg = isshort(ep) ? 2 : 4;
  2878.                         ap->offset = ep;     /* use as constant node */
  2879.                         gen_code(op_pea,0,ap,0);
  2880. rv = 4;
  2881. break;
  2882.                 case en_nacon:
  2883. ep->v.p[0] = ((SYM *)ep->v.p[0])->name;
  2884. case en_nalabcon:
  2885.                         ap = xalloc(sizeof(AMODE));
  2886. if (prm_rel) {
  2887.                         ap->preg = basereg;          /* frame pointer */
  2888. if (prm_largedata) {
  2889. ap1 = temp_addr();
  2890. ap->mode = am_areg;
  2891. gen_code(op_move,4,ap,ap1);
  2892. ap->mode = am_immed;
  2893. ap->offset = ep;
  2894. gen_code(op_add,4,ap,ap1);
  2895. ap = ap1;
  2896. ap->mode = am_ind;
  2897.                           gen_code(op_move,4,ap,push);
  2898.     ap->mode = am_areg;
  2899. freeop(ap);
  2900. }
  2901. else {
  2902.                          ap->mode = am_indx;
  2903.                          ap->offset = ep;     /* use as constant node */
  2904. gen_code(op_pea,0,ap,0);
  2905. }
  2906. }
  2907. else {
  2908. ap->mode = am_adirect;
  2909.                ap->offset = ep;
  2910. if (prm_smalldata) {
  2911. ap->preg = 2;
  2912. }
  2913. else {
  2914. ap->preg = 4;
  2915. }
  2916.   gen_code(op_pea,0,ap,0);
  2917. }
  2918. rv = 4;
  2919. break;
  2920. case en_cf:
  2921. case en_floatref:
  2922. ap = gen_expr(ep,F_FREG|F_INDX,6);
  2923. if (ap->mode == am_freg)
  2924. gen_codef(op_fmove,6,ap,push);
  2925. else
  2926. gen_code(op_move,4,ap,push);
  2927. rv = 4;
  2928. break;
  2929. case en_cd:
  2930. case en_doubleref:
  2931. ap = gen_expr(ep,F_FREG,8);
  2932. gen_codef(op_fmove,8,ap,push);
  2933. rv = 8;
  2934. break;
  2935. case en_cld:
  2936. case en_longdoubleref:
  2937. ap = gen_expr(ep,F_FREG,8);
  2938. gen_codef(op_fmove,10,ap,push);
  2939. rv = 8;
  2940. break;
  2941. case en_rcon:
  2942. case en_fcon:
  2943. case en_lrcon:
  2944. gen_codef(op_fmove,size,ap,push);
  2945. rv = size;
  2946. break;
  2947. default:
  2948. rv = 4;
  2949.           ap = gen_expr(ep,F_ALL,4);
  2950. if (ap->mode == am_freg)
  2951. gen_codef(op_fmove,4,ap,push);
  2952. else
  2953. gen_code(op_move,4,ap,push);
  2954. break;
  2955. }
  2956.         freeop(ap);
  2957. stackdepth += rv;
  2958. return(rv);
  2959. }
  2960. int push_stackblock(ENODE *ep)
  2961. {
  2962. AMODE *ap, *ap1, *ap2;
  2963. int lbl;
  2964. long sz = ep->size, tp;
  2965. long v;
  2966. if (!sz)
  2967. return(0);
  2968. if (sz & 1) {
  2969. tp = 1;
  2970. }
  2971. else if (sz & 2) {
  2972. tp = 2;
  2973. }
  2974. else {
  2975. tp = 4;
  2976. }
  2977. switch (ep->nodetype) {
  2978.                 case en_napccon:
  2979. ep->v.p[0] = ((SYM *)ep->v.p[0])->name;
  2980.                 case en_labcon:
  2981.                         ap = xalloc(sizeof(AMODE));
  2982. if (prm_rel)
  2983.                   ap->mode = am_pcindx;
  2984. else {
  2985. ap->mode = am_adirect;
  2986. if (prm_smallcode)
  2987. ap->preg = 2;
  2988. else
  2989. ap->preg = 4;
  2990. }
  2991.                         ap->offset = makenode(en_add,ep,makenode(en_icon,(char *)sz,0));     /* use as constant node */
  2992.                         gen_lea(0,ap,ap2 = temp_addr());
  2993. break;
  2994. case en_absacon:
  2995. ep->v.i = ((SYM *)ep->v.p[0])->value.i;
  2996.                         ap = xalloc(sizeof(AMODE));
  2997.                         ap->mode = am_adirect;
  2998. ap->preg = isshort(ep) ? 2 : 4;
  2999.                         ap->offset = makenode(en_add,ep,makenode(en_icon,(char *)sz,0));     /* use as constant node */
  3000.                         gen_lea(0,ap,ap2 = temp_addr());
  3001. break;
  3002.                 case en_nacon:
  3003. ep->v.p[0] = ((SYM *)ep->v.p[0])->name;
  3004. case en_nalabcon:
  3005. ap1 = 0;
  3006.                         ap = xalloc(sizeof(AMODE));
  3007. if (prm_rel) {
  3008.                         ap->preg = basereg;          /* frame pointer */
  3010. if (prm_largedata) {
  3011. ap1 = temp_addr();
  3012. ap->mode = am_areg;
  3013. gen_code(op_move,4,ap,ap1);
  3014. ap->mode = am_immed;
  3015. ap->offset = ep;
  3016. gen_code(op_add,4,ap,ap1);
  3017. ap = ap1;
  3018. ap->mode = am_ind;
  3019. }
  3020. else {
  3021.                          ap->mode = am_indx;
  3022.                          ap->offset = ep;     /* use as constant node */
  3023. }
  3024. }
  3025. else {
  3026. ap->mode = am_adirect;
  3027.                ap->offset = ep;
  3028. if (prm_smalldata) {
  3029. ap->preg = 2;
  3030. }
  3031. else {
  3032. ap->preg = 4;
  3033. }
  3034. }
  3035.                         ap->offset = makenode(en_add,ep,makenode(en_icon,(char *)sz,0));     /* use as constant node */
  3036.                         gen_lea(0,ap,ap2=temp_addr());
  3037. if (ap1) {
  3038. ap1->mode = am_areg;
  3039. freeop(ap1);
  3040. }
  3041. break;
  3042.                 case en_autocon:
  3043.                 case en_autoreg:
  3044. ep->v.i = ((SYM *)ep->v.p[0])->value.i;
  3045.                         ap = xalloc(sizeof(AMODE));
  3046.                         ap->mode = am_indx;
  3047. if (prm_linkreg && !currentfunc->intflag) {
  3048.                  ap->preg = linkreg;
  3049.                          ap->offset = makenode(en_add,ep,makenode(en_icon,(char *)sz,0));     /* use as constant node */
  3050. }
  3051.   else if (((SYM *)ep->v.p[0])->funcparm ) {
  3052. if (prm_phiform || currentfunc->intflag) {
  3053.                          ap->preg = linkreg;          /* frame pointer */
  3054.                          ap->offset = makenode(en_add,ep,makenode(en_icon,(char *)sz,0));     /* use as constant node */
  3055. }
  3056. else {
  3057. ap->preg = 7;
  3058.                          ap->offset = makenode(en_add,ep,makenode(en_icon,(char *)(sz+stackdepth+framedepth),0));     /* use as constant node */
  3059. }
  3060.                  }
  3061. else {
  3062. ap->preg = 7;
  3063.                          ap->offset = makenode(en_add,ep,makenode(en_icon,(char *)(sz+stackdepth+lc_maxauto),0));     /* use as constant node */
  3064. }
  3065.                         gen_lea(0,ap,ap2 = temp_addr());
  3066. break;
  3067. default:
  3068. ap = 0;
  3069.           ap2 = gen_expr(ep,F_AREG | F_VOL,4);
  3070. gen_code(op_add,4,make_immed(sz),ap2);
  3071. break;
  3072. }
  3073. lbl = nextlabel++;
  3074. ap1 = temp_data();
  3075.   v = sz/tp;
  3076. if (v < 65536)
  3077. v--;
  3078. gen_code(op_move,v < 65536 ? 2 : 4,make_immed(v),ap1);
  3079. gen_label(lbl);
  3080. ap2->mode = am_adec;
  3081. gen_code(op_move,tp,ap2,push);
  3082. if (v < 65536) {
  3083. gen_code(op_dbra,0,ap1,make_label(lbl));
  3084. }
  3085. else {
  3086. gen_code(op_sub,4,make_immed(1),ap1);
  3087. gen_code(op_bne,0,make_label(lbl),0);
  3088. }
  3089. freeop(ap1);
  3090. freeop(ap2);
  3091. if (ap)
  3092.    freeop(ap);
  3094. stackdepth += sz;
  3095. return(sz);
  3096. }
  3098. int     gen_parms(ENODE *plist,int size)
  3099. /*
  3100.  *      push a list of parameters onto the stack and return the
  3101.  *      size of parameters pushed.
  3102.  */
  3103. {       int     i;
  3104.         i = 0;
  3105.         while( plist != 0 )
  3106.                 {         
  3107. if (plist->nodetype == en_stackblock)
  3108. i+=push_stackblock(plist->v.p[0]);
  3109. else
  3110.                  i+=push_param(plist->v.p[0],size);
  3111.                 plist = plist->v.p[1];
  3112.                 }
  3113.         return i;
  3114. }
  3115. AMODE    *gen_fcall(ENODE *node,int flags, int size)
  3116. /*
  3117.  *      generate a function call node and return the address mode
  3118.  *      of the result.
  3119.  */
  3120. {       AMODE    *ap, *result, *ap1;
  3121.         int             i,siz1;
  3122.         result = temp_addr();
  3123.         temp_addr();                    /* push any used addr temps */
  3124.         freeop(result); freeop(result);
  3125.         result = temp_data();
  3126.         temp_data(); temp_data();      /* push any used data registers */
  3127.         freeop(result); freeop(result); freeop(result);
  3128. result = temp_float();  temp_float(); temp_float();
  3129.         freeop(result); freeop(result); freeop(result);
  3130. if (node->nodetype == en_callblock) {
  3131. i = gen_parms(node->v.p[1]->v.p[1]->v.p[1]->v.p[0],size);
  3132.        ap = gen_expr(node->v.p[0],F_ALL,4);
  3133. gen_code(op_move,4,ap,push);
  3134. i+=4;
  3135. stackdepth+=4;
  3136. node=node->v.p[1];
  3137. freeop(ap);
  3138. siz1 = 4;
  3139. }
  3140. else {
  3141.         i = gen_parms(node->v.p[1]->v.p[1]->v.p[0],size);    /* generate parameters */
  3142. siz1 = node->v.p[0]->v.i;
  3143. }
  3144. if ((prm_phiform || node->nodetype == en_trapcall || node->nodetype == en_intcall) && i)
  3145. gen_code(op_move,4,makeareg(7),makeareg(0));
  3146. if (node->nodetype == en_trapcall) {
  3147. gen_code(op_trap,0,make_immed(node->v.p[1]->v.p[0]->v.i),0);
  3148. }
  3149. else if (node->nodetype == en_intcall) {
  3150. /* This is one case where we can generate code that will run
  3151.  * on a 68000 but not on a 68020 or vice versa*/
  3152. int curlabel = nextlabel++;
  3153. DIAG("Direct calls to interrups not portable across processors");
  3154. if (prm_68020) {
  3155. gen_code(op_clr,2,push,0);
  3156. }
  3157. else
  3158. ap1 = make_label(curlabel);
  3159. if (prm_rel)
  3160.      ap1->mode = am_pcindx;
  3161. else {
  3162. ap1->mode = am_adirect;
  3163.   if (prm_smallcode)
  3164. ap1->preg = 2;
  3165. else
  3166. ap1->preg = 4;
  3167. }
  3168. gen_code(op_pea,4,ap1,0);
  3169. ap1 = xalloc(sizeof(AMODE));
  3170. ap1->mode = am_sr;
  3171. gen_code(op_move,2,ap1,push); /* May cause an exception on an 020 */
  3172. gen_code(op_bra,0,make_offset(node->v.p[1]->v.p[0]),0);
  3173. gen_label(curlabel);
  3174. freeop(ap1);
  3175. }
  3176.         else if( node->v.p[1]->v.p[0]->nodetype == en_nacon || node->v.p[1]->v.p[0]->nodetype == en_napccon ) {
  3177. SYM * sp = node->v.p[1]->v.p[0]->v.p[0];
  3178. if (sp->inreg) {
  3179. if (sp->value.i < 8)
  3180. ap1 = makedreg(sp->value.i);
  3181. else
  3182. ap1 = makeareg(sp->value.i & 7);
  3183. make_legal(ap1,F_AREG,size);
  3184. ap1->mode = am_ind;
  3185. gen_code(op_jsr,0,ap1,0);
  3186. }
  3187. else {
  3188. node->v.p[1]->v.p[0]->v.p[0] = sp->name;
  3189. if (prm_rel)
  3190.              gen_code(op_bsr,0,make_offset(node->v.p[1]->v.p[0]),0);
  3191. else {
  3192. ap1 = xalloc(sizeof(AMODE));
  3193. ap1->mode = am_adirect;
  3194.            ap1->offset = node->v.p[1]->v.p[0];
  3195. if (prm_smallcode) {
  3196. ap1->preg = 2;
  3197. }
  3198. else {
  3199. ap1->preg = 4;
  3200. }
  3201. gen_code(op_jsr,0,ap1,0);
  3202. }
  3203. }
  3204.     }
  3205.         else
  3206.                 {
  3207.                 ap = gen_expr(node->v.p[1]->v.p[0],F_AREG,4);
  3208. ap->mode = am_ind;
  3209.                 freeop(ap);
  3210.                 gen_code(op_jsr,0,ap,0);
  3211.                 }
  3212.         if( i != 0 ) {
  3213. if (i > 8) {
  3214. AMODE *ap = xalloc(sizeof(AMODE)); 
  3215. ap->mode = am_indx;
  3216. ap->offset = makenode(en_icon,(char *)i,0);
  3217. ap->preg = 7;
  3218.                  gen_lea(0,ap,makeareg(7));
  3219. }
  3220. else
  3221.                  gen_code(op_add,4,make_immed(i),makeareg(7));
  3222. stackdepth -= i;
  3223. }
  3224. if (siz1 > 4) {
  3225. result = temp_float();
  3226. if (result->preg != 0)
  3227. gen_codef(op_fmove,8,makefreg(0),result);
  3228. }
  3229. else {
  3230.           result = temp_data();
  3231.          if( result->preg != 0)
  3232.                 gen_code(op_move,4,makedreg(0),result);
  3233. }
  3234. result->tempflag = 1;
  3235. do_extend(result,siz1,size,flags);
  3236. make_legal(result,flags,size);
  3237.         return result;
  3238. }
  3239. AMODE    *gen_pfcall(ENODE *node,int flags, int size)
  3240. /*
  3241.  *      generate a function call node for pascal function calls
  3242. * and return the address mode of the result.
  3243.  */
  3244. {       AMODE    *ap, *result, *ap1;
  3245.         int             i,siz1;
  3246. ENODE * invnode = 0,*anode;
  3248. /* invert the parameter list */
  3249. if (node->nodetype == en_pcallblock)
  3250. anode = node->v.p[1]->v.p[1]->v.p[1]->v.p[0];
  3251. else
  3252. anode = node->v.p[1]->v.p[1]->v.p[0];
  3253. while (anode) {
  3254. invnode = makenode(anode->nodetype,anode->v.p[0],invnode);
  3255. anode = anode->v.p[1];
  3256. }
  3257.         result = temp_addr();
  3258.         temp_addr();                    /* push any used addr temps */
  3259.         freeop(result); freeop(result);
  3260.         result = temp_data();
  3261.         temp_data(); temp_data();      /* push any used data registers */
  3262.         freeop(result); freeop(result); freeop(result);
  3263. result = temp_float();  temp_float(); temp_float();
  3264.         freeop(result); freeop(result); freeop(result);
  3265. if (node->nodetype == en_pcallblock) {
  3266.        ap = gen_expr(node->v.p[0],F_ALL,4);
  3267. gen_code(op_move,4,ap,push);
  3268. freeop(ap);
  3269. i =4;
  3270. stackdepth+=4;
  3271. i += gen_parms(invnode,size);
  3272. node=node->v.p[1];
  3273. siz1 = 4;
  3274. }
  3275. else {
  3276.         i = gen_parms(invnode,size);    /* generate parameters */
  3277. siz1 = node->v.p[0]->v.i;
  3278. }
  3279. if ((prm_phiform || node->nodetype == en_trapcall || node->nodetype == en_intcall) && i)
  3280. gen_code(op_move,4,makeareg(7),makeareg(0));
  3281.         if( node->v.p[1]->v.p[0]->nodetype == en_nacon || node->v.p[1]->v.p[0]->nodetype == en_napccon ) {
  3282. SYM * sp = node->v.p[1]->v.p[0]->v.p[0];
  3283. if (sp->inreg) {
  3284. if (sp->value.i < 8)
  3285. ap1 = makedreg(sp->value.i);
  3286. else
  3287. ap1 = makeareg(sp->value.i & 7);
  3288. make_legal(ap1,F_AREG,size);
  3289. ap1->mode = am_ind;
  3290. gen_code(op_jsr,0,ap1,0);
  3291. }
  3292. else {
  3293. node->v.p[1]->v.p[0]->v.p[0] = sp->name;
  3294. if (prm_rel)
  3295.              gen_code(op_bsr,0,make_offset(node->v.p[1]->v.p[0]),0);
  3296. else {
  3297. ap1 = xalloc(sizeof(AMODE));
  3298. ap1->mode = am_adirect;
  3299.            ap1->offset = node->v.p[1]->v.p[0];
  3300. if (prm_smallcode) {
  3301. ap1->preg = 2;
  3302. }
  3303. else {
  3304. ap1->preg = 4;
  3305. }
  3306. gen_code(op_jsr,0,ap1,0);
  3307. }
  3308. }
  3309.     }
  3310.         else
  3311.                 {
  3312.                 ap = gen_expr(node->v.p[1]->v.p[0],F_AREG,4);
  3313. ap->mode = am_ind;
  3314.                 freeop(ap);
  3315.                 gen_code(op_jsr,0,ap,0);
  3316.                 }
  3317. stackdepth -= i;
  3318. if (siz1 > 4) {
  3319. result = temp_float();
  3320. if (result->preg != 0)
  3321. gen_codef(op_fmove,8,makefreg(0),result);
  3322. }
  3323. else {
  3324.           result = temp_data();
  3325.          if( result->preg != 0)
  3326.                 gen_code(op_move,4,makedreg(0),result);
  3327. }
  3328. result->tempflag = 1;
  3329. do_extend(result,siz1,size,flags);
  3330. make_legal(result,flags,size);
  3331.         return result;
  3332. }
  3334. AMODE    *gen_expr(ENODE *node, int flags, int size)
  3335. /*
  3336.  *      general expression evaluation. returns the addressing mode
  3337.  *      of the result.
  3338.  */
  3339. {
  3340. AMODE    *ap1, *ap2;
  3341.         int             lab0, lab1;
  3342.         int             natsize;
  3343.         if( node == 0 )
  3344.                 {
  3345.                 DIAG("null node in gen_expr.");
  3346.                 return 0;
  3347.                 }
  3348.         switch( node->nodetype )
  3349.                 {
  3350. case en_cb: 
  3351. case en_cub:
  3352. case en_cw: 
  3353. case en_cuw:
  3354. case en_cl: 
  3355. case en_cul:
  3356. case en_cf: 
  3357. case en_cd: 
  3358. case en_cld: 
  3359. case en_cp:
  3360. ap1 = gen_expr(node->v.p[0],flags | F_INDX | F_DREG | F_FREG,natural_size(node->v.p[0]));
  3361.                  do_extend(ap1,natural_size(node->v.p[0]),size,flags);
  3362. make_legal(ap1,flags,size);
  3363. return ap1;
  3364.                 case en_napccon:
  3365. node->v.p[0] = ((SYM *)node->v.p[0])->name;
  3366.                 case en_labcon:
  3367.                         ap1 = temp_addr();
  3368. ap1->tempflag = TRUE;
  3369.                         ap2 = xalloc(sizeof(AMODE));
  3370. if (prm_rel)
  3371.      ap2->mode = am_pcindx;
  3372. else {
  3373. ap2->mode = am_adirect;
  3374.   if (prm_smallcode)
  3375. ap2->preg = 2;
  3376. else
  3377. ap2->preg = 4;
  3378. }
  3379.                         ap2->offset = node;     /* use as constant node */
  3380.                         gen_lea(0,ap2,ap1);
  3381.                         make_legal(ap1,flags,size);
  3382.                         return ap1;             /* return reg */
  3383. case en_absacon:
  3384. node->v.i = ((SYM *)node->v.p[0])->value.i;
  3385.                         ap1 = temp_addr();
  3386. ap1->tempflag = TRUE;
  3387.                         ap2 = xalloc(sizeof(AMODE));
  3388.                         ap2->mode = am_adirect;
  3389. ap2->preg = isshort(node) ? 2 : 4;
  3390.                         ap2->offset = node;     /* use as constant node */
  3391.                         gen_lea(0,ap2,ap1);
  3392.                         make_legal(ap1,flags,size);
  3393.                         return ap1;             /* return reg */
  3394.                 case en_nacon:
  3395. node->v.p[0] = ((SYM *)node->v.p[0])->name;
  3396. case en_nalabcon:
  3397.                       ap1 = temp_addr();
  3398. ap1->tempflag = TRUE;
  3399.                        ap2 = xalloc(sizeof(AMODE));
  3400. if (prm_rel) {
  3401.                         ap2->preg = basereg;          /* frame pointer */
  3402. if (prm_largedata) {
  3403. ap2->mode = am_areg;
  3404. gen_code(op_move,0,ap2,ap1);
  3405. ap2->mode = am_immed;
  3406. ap2->offset = node;
  3407. gen_code(op_add,0,ap2,ap1);
  3408. }
  3409. else {
  3410.                          ap2->mode = am_indx;
  3411.                           ap2->offset = node;     /* use as constant node */
  3412.                          gen_lea(0,ap2,ap1);
  3413. }
  3414. }
  3415. else {
  3416. ap2->mode = am_adirect;
  3417.                ap2->offset = node;
  3418. if (prm_smalldata) {
  3419. ap2->preg = 2;
  3420. }
  3421. else {
  3422. ap2->preg = 4;
  3423. }
  3424.                        gen_lea(0,ap2,ap1);
  3425. }
  3426.                         make_legal(ap1,flags,size);
  3427.                         return ap1;             /* return reg */
  3428.                 case en_icon:
  3429. case en_lcon: 
  3430. case en_lucon: 
  3431. case en_iucon: 
  3432. case en_ccon:                 
  3433. case en_rcon:
  3434. case en_lrcon: case en_fcon:
  3435.                         ap1 = xalloc(sizeof(AMODE));
  3436.                         ap1->mode = am_immed;
  3437.                         ap1->offset = node;
  3438.                         make_legal(ap1,flags,size);
  3439.                         return ap1;
  3440.                 case en_autocon:
  3441.                 case en_autoreg:
  3442.                         ap1 = temp_addr();
  3443. ap1->tempflag = TRUE;
  3444.                         ap2 = xalloc(sizeof(AMODE));
  3445.                         ap2->mode = am_indx;
  3446. if (prm_linkreg && !currentfunc->intflag) {
  3447.                  ap2->preg = linkreg;
  3448.                   ap2->offset = makenode(en_icon,(char *)((SYM *)node->v.p[0])->value.i,0);
  3449. }
  3450.   else if (((SYM *)node->v.p[0])->funcparm ) {
  3451. if (prm_phiform || currentfunc->intflag) {
  3452.                          ap2->preg = linkreg;          /* frame pointer */
  3453. ap2->offset = makenode(en_icon,(char *)(((SYM *)node->v.p[0])->value.i),0);
  3454. }
  3455. else {
  3456. ap2->preg = 7;
  3457. ap2->offset = makenode(en_icon,(char *)(((SYM *)node->v.p[0])->value.i+stackdepth+framedepth),0);
  3458. }
  3459.                  }
  3460. else {
  3461. ap2->preg = 7;
  3462. ap2->offset = makenode(en_icon,(char *)(((SYM *)node->v.p[0])->value.i+stackdepth+lc_maxauto),0);
  3463. }
  3464.                         gen_lea(0,ap2,ap1);
  3465.                         make_legal(ap1,flags,size);
  3466.                         return ap1;             /* return reg */
  3467.                 case en_b_ref:
  3468.                 case en_w_ref:
  3469.                 case en_ub_ref:
  3470.                 case en_uw_ref:
  3471.                 case en_l_ref:
  3472.                 case en_ul_ref:
  3473. case en_floatref:
  3474. case en_doubleref:
  3475. case en_longdoubleref:
  3476.                         ap1 = gen_deref(node,flags,size,FALSE);
  3477. return ap1;
  3478.                 case en_tempref:
  3479.                 case en_regref:
  3480.                         ap1 = xalloc(sizeof(AMODE));
  3481.                         if( (node->v.i & 0xff) < 16 )
  3482.                                 {
  3483.                                 ap1->mode = am_dreg;
  3484.                                 ap1->preg = node->v.i & 0xff;
  3485.                                 }
  3486.                         else
  3487. if ((node->v.i &0xff) < 32)
  3488.                                 {
  3489.                                 ap1->mode = am_areg;
  3490.                                 ap1->preg = (node->v.i & 0xff) - 16;
  3491.                                 }
  3492. else
  3493.                                 {
  3494.                                 ap1->mode = am_freg;
  3495.                                 ap1->preg = (node->v.i &0xff)- 32;
  3496.                                 }
  3497.                         ap1->tempflag = 0;      /* not a temporary */
  3498.                  do_extend(ap1,node->v.i >> 8,size,flags);
  3499.                         make_legal(ap1,flags,size);
  3500.                         return ap1;
  3501. case en_bits:
  3502. size = natural_size(node->v.p[0]);
  3503. ap1 = gen_expr(node->v.p[0],F_ALL,size);
  3504. if (!(flags & F_NOBIT))
  3505. bit_legal(ap1,node,size);
  3506. return ap1;
  3507.                 case en_uminus:
  3508.                         return gen_unary(node,flags,size,op_neg, op_fneg);
  3509.                 case en_compl:
  3510.                         return gen_unary(node,flags,size,op_not, op_not);
  3511.                 case en_add:
  3512.                         return gen_binary(node,flags,size,op_add,op_fadd);
  3513.                 case en_sub:
  3514.                         return gen_binary(node,flags,size,op_sub,op_fsub);
  3515.                 case en_and:
  3516.                         return gen_binary(node,flags,size,op_and,op_and);
  3517.                 case en_or:
  3518.                         return gen_binary(node,flags,size,op_or,op_or);
  3519. case en_xor:
  3520. return gen_xbin(node,flags,size,op_eor,op_eor);
  3521. case en_pmul:
  3522. return gen_pmul(node,flags,size);
  3523. case en_pdiv:
  3524. return gen_pdiv(node,flags,size);
  3525.                 case en_mul:
  3526.                         return gen_mul(node,flags,size,op_muls);
  3527.                 case en_umul:
  3528.                         return gen_mul(node,flags,size,op_mulu);
  3529.                 case en_div:
  3530.                         return gen_modiv(node,flags,size,op_divs,0);
  3531.                 case en_udiv:
  3532.                         return gen_modiv(node,flags,size,op_divu,0);
  3533.                 case en_mod:
  3534.                         return gen_modiv(node,flags,size,op_divs,1);
  3535.                 case en_umod:
  3536.                         return gen_modiv(node,flags,size,op_divu,1);
  3537.                 case en_alsh:
  3538.                         return gen_shift(node,flags,size,op_asl);
  3539.                 case en_arsh:
  3540.                         return gen_shift(node,flags,size,op_asr);
  3541.                 case en_lsh:
  3542.                         return gen_shift(node,flags,size,op_lsl);
  3543.                 case en_rsh:
  3544.                         return gen_shift(node,flags,size,op_lsr);
  3545.                 case en_asadd:
  3546.                         return gen_asadd(node,flags,size,op_add,op_fadd);
  3547.                 case en_assub:
  3548.                         return gen_asadd(node,flags,size,op_sub,op_fsub);
  3549.                 case en_asand:
  3550.                         return gen_aslogic(node,flags,size,op_and);
  3551.                 case en_asor:
  3552.                         return gen_aslogic(node,flags,size,op_or);
  3553.                 case en_asxor:
  3554.                         return gen_aslogic(node,flags,size,op_eor);
  3555.                 case en_aslsh:
  3556.                         return gen_asshift(node,flags,size,op_lsl);
  3557.                 case en_asrsh:
  3558.                         return gen_asshift(node,flags,size,op_lsr);
  3559.                 case en_asalsh:
  3560.                         return gen_asshift(node,flags,size,op_asl);
  3561.                 case en_asarsh:
  3562.                         return gen_asshift(node,flags,size,op_asr);
  3563.                 case en_asmul:
  3564.                         return gen_asmul(node,flags,size, op_muls);
  3565.                 case en_asumul:
  3566.                         return gen_asmul(node,flags,size,op_mulu);
  3567.                 case en_asdiv:
  3568.                         return gen_asmodiv(node,flags,size,op_divs,FALSE);
  3569.                 case en_asudiv:
  3570.                         return gen_asmodiv(node,flags,size,op_divu,FALSE);
  3571.                 case en_asmod:
  3572.                         return gen_asmodiv(node,flags,size,op_divs,TRUE);
  3573.                 case en_asumod:
  3574.                         return gen_asmodiv(node,flags,size,op_divu,TRUE);
  3575.                 case en_assign:
  3576.                         return gen_assign(node,flags,size);
  3577.                 case en_refassign:
  3578.                         return gen_refassign(node,flags | F_NOVALUE,size);
  3579.                 case en_moveblock:
  3580.                         return gen_moveblock(node,flags,size);
  3581.                 case en_ainc:
  3582.                         return gen_aincdec(node,flags,size,op_add);
  3583.                 case en_adec:
  3584.                         return gen_aincdec(node,flags,size,op_sub);
  3585.                 case en_land:   case en_lor:
  3586.                 case en_eq:     case en_ne:
  3587.                 case en_lt:     case en_le:
  3588.                 case en_gt:     case en_ge:
  3589.                 case en_ult:    case en_ule:
  3590.                 case en_ugt:    case en_uge:
  3591.                 case en_not:
  3592.                         lab0 = nextlabel++;
  3593.                         lab1 = nextlabel++;
  3594.                         falsejp(node,lab0);
  3595.                         ap1 = temp_data();
  3596.                         gen_code(op_moveq,0,make_immed(1),ap1);
  3597.                         gen_code(op_bra,0,make_label(lab1),0);
  3598.                         gen_label(lab0);
  3599.                         gen_code(op_clr,4,ap1,0);
  3600.                         gen_label(lab1);
  3601.                         return ap1;
  3602.                 case en_cond:
  3603.                         return gen_hook(node,flags,size);
  3604.                 case en_void:
  3605.                         natsize = natural_size(node->v.p[0]);
  3606.                         freeop(gen_expr(node->v.p[0],F_ALL | F_NOVALUE,natsize));
  3607.                         return gen_expr(node->v.p[1],flags,size);
  3608. case en_pfcall: case en_pfcallb:
  3609. case en_pcallblock:
  3610.                         return gen_pfcall(node,flags,size);
  3611.                 case en_fcall:  case en_callblock: case en_fcallb:
  3612.                 case en_intcall: 
  3613.                 case en_trapcall:
  3614.                         return gen_fcall(node,flags,size);
  3615.                 default:
  3616.                         DIAG("uncoded node in gen_expr.");
  3617.                         return 0;
  3618.                 }
  3619. }
  3621. int     natural_size(ENODE *node)
  3622. /*
  3623.  *      return the natural evaluation size of a node.
  3624.  */
  3625. {       int     siz0, siz1;
  3626.         if( node == 0 )
  3627.                 return 0;
  3628.         switch( node->nodetype )
  3629.                 {
  3630. case en_bits:
  3631. return stdintsize;
  3632.                 case en_icon:
  3633. case en_lcon: 
  3634. case en_lucon: 
  3635.                 case en_iucon:
  3636. return 0;
  3637. case en_ccon:                 
  3638. return 0;
  3639. case en_rcon:
  3640. case en_doubleref:
  3641. return 8;
  3642. case en_lrcon:
  3643. case en_longdoubleref:
  3644. return stdldoublesize;
  3645. case en_fcon:
  3646. case en_floatref:
  3647. return 6;
  3648. case en_trapcall:
  3649.                 case en_labcon:
  3650.                 case en_nacon:  case en_autocon:  case en_autoreg:
  3651.                 case en_napccon:  case en_absacon: case en_nalabcon:
  3652. return stdaddrsize;
  3653. case en_l_ref:
  3654. case en_cl:
  3655. return -4;
  3656. case en_pfcall: case en_pfcallb: /* ignore pascal style now */
  3657. case en_pcallblock:
  3658. case en_fcall: case en_callblock: case en_fcallb:
  3659. case en_intcall:
  3660. return natural_size(node->v.p[1]);
  3661. case en_tempref:
  3662. case en_regref:
  3663. return node->v.i >> 8;
  3664.                 case en_ul_ref:
  3665. case en_cul:
  3666.                         return 4;
  3667. case en_cp:
  3668. return stdaddrsize;
  3669.                 case en_ub_ref:
  3670. case en_cub:
  3671. return 1;
  3672.                 case en_b_ref:
  3673. case en_cb:
  3674.                         return -1;
  3675.                 case en_uw_ref:
  3676. case en_cuw:
  3677. return 2;
  3678.                 case en_cw:
  3679.                 case en_w_ref:
  3680.                         return -2;
  3681. case en_cd:
  3682. return 8;
  3683. case en_cld:
  3684. return 10;
  3685. case en_cf:
  3686. return 6;
  3687.                 case en_not:    case en_compl:
  3688.                 case en_uminus: case en_assign: case en_refassign:
  3689.                 case en_ainc:   case en_adec:
  3690. case en_moveblock: case en_stackblock:
  3691.                         return natural_size(node->v.p[0]);
  3692.                 case en_add:    case en_sub:
  3693. case en_umul: case en_udiv: case en_umod: case en_pmul:
  3694.                 case en_mul:    case en_div:  case en_pdiv:
  3695.                 case en_mod:    case en_and:
  3696.                 case en_or:     case en_xor:
  3697. case en_asalsh: case en_asarsh: case en_alsh: case en_arsh:
  3698.                 case en_lsh:    case en_rsh:
  3699.                 case en_eq:     case en_ne:
  3700.                 case en_lt:     case en_le:
  3701.                 case en_gt:     case en_ge:
  3702. case en_ugt: case en_uge: case en_ult: case en_ule:
  3703.                 case en_land:   case en_lor:
  3704.                 case en_asadd:  case en_assub:
  3705.                 case en_asmul:  case en_asdiv:
  3706.                 case en_asmod:  case en_asand:
  3707. case en_asumod: case en_asudiv: case en_asumul:
  3708.                 case en_asor:   case en_aslsh:  case en_asxor:
  3709.                 case en_asrsh:
  3710.                         siz0 = natural_size(node->v.p[0]);
  3711.                         siz1 = natural_size(node->v.p[1]);
  3712.                         if( chksize(siz1,siz0))
  3713.                                 return siz1;
  3714.                         else
  3715.                                 return siz0;
  3716.                 case en_void:   case en_cond:
  3717.                         return natural_size(node->v.p[1]);
  3718.                 default:
  3719.                         DIAG("natural size error.");
  3720.                         break;
  3721.                 }
  3722.         return 0;
  3723. }
  3725. void gen_compare(ENODE *node, int btype1, int btype2, int btype3, int btype4, int label)
  3726. /*
  3727.  *      generate code to do a comparison of the two operands of
  3728.  *      node.
  3729.  */
  3730. {       AMODE    *ap1, *ap2,  *ap3;
  3731.         int             size;
  3732. int btype = btype1;
  3733. ap3 = 0;
  3734.         size = natural_size(node);
  3735. if (size > 4) {
  3736.          ap1 = gen_expr(node->v.p[0],F_FREG,size);
  3737. mark();
  3738.          ap2 = gen_expr(node->v.p[1],F_ALL,size);
  3739.          gen_code(op_fcmp,size,ap2,ap1);
  3740.          gen_code(btype3,0,make_label(label),0);
  3741. freeop(ap2);
  3742. freeop(ap1);
  3743. release();
  3744. return;
  3745. }
  3746.         ap1 = gen_expr(node->v.p[0],F_ALL,size);
  3747. mark();
  3748.         ap2 = gen_expr(node->v.p[1],F_ALL,size);
  3749. if (ap1->mode != am_dreg && ap1->mode != am_areg) {
  3750. if (ap2->mode == am_immed)  {
  3751. if (ap1->mode == am_immed)
  3752. goto cmp2;
  3753. }
  3754. else {
  3755. if (ap2->mode == am_dreg || ap2->mode == am_areg) {
  3756. swapit:
  3757. ap3 = ap2;
  3758. ap2 = ap1;
  3759. ap1 = ap3;
  3760. ap3 = 0;
  3761. btype = btype2;
  3762. }
  3763. else  
  3764. if (ap1->mode == am_immed) {
  3765. goto swapit;
  3766. }
  3767. else {
  3768. cmp2:
  3769. ap3 = ap1;
  3770.                ap1 = temp_data();
  3771. gen_code(op_move,size,ap3,ap1);
  3772.                make_legal(ap1,F_DREG,size);
  3773. }
  3774. }
  3775. }
  3776.         gen_code(op_cmp,size,ap2,ap1);
  3777.         gen_code(btype,0,make_label(label),0);
  3778. if (ap3) {
  3779. freeop(ap1);
  3780. freeop(ap2);
  3781. freeop(ap3);
  3782. }
  3783. else {
  3784.          freeop(ap2);
  3785.          freeop(ap1);
  3786. }
  3787. release();
  3788. }
  3790. void truejp(ENODE *node, int label)
  3791. /*
  3792.  *      generate a jump to label if the node passed evaluates to
  3793.  *      a true condition.
  3794.  */
  3795. {       AMODE    *ap1;
  3796.         int             siz1;
  3797.         int             lab0;
  3798.         if( node == 0 )
  3799.                 return;
  3800.         switch( node->nodetype )
  3801.                 {
  3802.                 case en_eq:
  3803.                         gen_compare(node,op_beq,op_beq,op_fbeq,op_fbeq,label);
  3804.                         break;
  3805.                 case en_ne:
  3806.                         gen_compare(node,op_bne,op_bne,op_fbne,op_fbne,label);
  3807.                         break;
  3808.                 case en_lt:
  3809.                         gen_compare(node,op_blt,op_bgt,op_fblt,op_fbgt,label);
  3810.                         break;
  3811.                 case en_le:
  3812.                         gen_compare(node,op_ble,op_bge,op_fble,op_fbge,label);
  3813.                         break;
  3814.                 case en_gt:
  3815.                         gen_compare(node,op_bgt,op_blt,op_fbgt,op_fblt,label);
  3816.                         break;
  3817.                 case en_ge:
  3818.                         gen_compare(node,op_bge,op_ble,op_fbge,op_fble,label);
  3819.                         break;
  3820.                 case en_ult:
  3821.                         gen_compare(node,op_blo,op_bhi,op_fblt,op_fbgt,label);
  3822.                         break;
  3823.                 case en_ule:
  3824.                         gen_compare(node,op_bls,op_bhs,op_fble,op_fbge,label);
  3825.                         break;
  3826.                 case en_ugt:
  3827.                         gen_compare(node,op_bhi,op_blo,op_fbgt,op_fblt,label);
  3828.                         break;
  3829.                 case en_uge:
  3830.                         gen_compare(node,op_bhs,op_bls,op_fbge,op_fble,label);
  3831.                         break;
  3832.                 case en_land:
  3833.                         lab0 = nextlabel++;
  3834.                         falsejp(node->v.p[0],lab0);
  3835.                         truejp(node->v.p[1],label);
  3836.                         gen_label(lab0);
  3837.                         break;
  3838.                 case en_lor:
  3839.                         truejp(node->v.p[0],label);
  3840.                         truejp(node->v.p[1],label);
  3841.                         break;
  3842.                 case en_not:
  3843.                         falsejp(node->v.p[0],label);
  3844.                         break;
  3845.                 default:
  3846.                         siz1 = natural_size(node);    
  3847. if (isintconst(node->nodetype)) {
  3848. if (node->v.i != 0)
  3849.                          gen_code(op_bra,0,make_label(label),0);
  3850.               break;
  3851. }
  3852. else {
  3853. if (siz1 > 4)
  3854.                          ap1 = gen_expr(node,F_FREG,siz1);
  3855. else
  3856.                          ap1 = gen_expr(node,F_DREG | F_INDX,siz1);
  3857. }
  3858. if (siz1 > 4) {
  3859.                          gen_codef(op_ftst,siz1,ap1,0);
  3860.                          freeop(ap1);
  3861.                          gen_code(op_fbne,0,make_label(label),0);
  3862. }
  3863. else {
  3864.                          gen_code(op_tst,siz1,ap1,0);
  3865.                          freeop(ap1);
  3866.                          gen_code(op_bne,0,make_label(label),0);
  3867. }
  3868.                         break;
  3869.                 }
  3870. }
  3872. void falsejp(ENODE *node, int label)
  3873. /*
  3874.  *      generate code to execute a jump to label if the expression
  3875.  *      passed is false.
  3876.  */
  3877. {       AMODE    *ap;
  3878.         int             siz1;
  3879.         int             lab0;
  3880.         if( node == 0 )
  3881.                 return;
  3882.         switch( node->nodetype )
  3883.                 {
  3884.                 case en_eq:
  3885.                         gen_compare(node,op_bne,op_bne,op_fbne,op_fbne,label);
  3886.                         break;
  3887.                 case en_ne:
  3888.                         gen_compare(node,op_beq,op_beq,op_fbeq,op_fbeq,label);
  3889.                         break;
  3890.                 case en_lt:
  3891.                         gen_compare(node,op_bge,op_ble,op_fbge,op_fble,label);
  3892.                         break;
  3893.                 case en_le:
  3894.                         gen_compare(node,op_bgt,op_blt,op_fbgt,op_fblt,label);
  3895.                         break;
  3896.                 case en_gt:
  3897.                         gen_compare(node,op_ble,op_bge,op_fble,op_fbge,label);
  3898.                         break;
  3899.                 case en_ge:
  3900.                         gen_compare(node,op_blt,op_bgt,op_fblt,op_fbgt,label);
  3901.                         break;
  3902.                 case en_ult:
  3903.                         gen_compare(node,op_bhs,op_bls,op_fbge,op_fble,label);
  3904.                         break;
  3905.                 case en_ule:
  3906.                         gen_compare(node,op_bhi,op_blo,op_fbgt,op_fblt,label);
  3907.                         break;
  3908.                 case en_ugt:
  3909.                         gen_compare(node,op_bls,op_bhs,op_fble,op_fbge,label);
  3910.                         break;
  3911.                 case en_uge:
  3912.                         gen_compare(node,op_blo,op_bhi,op_fblt,op_fbgt,label);
  3913.                         break;
  3914.                 case en_land:
  3915.                         falsejp(node->v.p[0],label);
  3916.                         falsejp(node->v.p[1],label);
  3917.                         break;
  3918.                 case en_lor:
  3919.                         lab0 = nextlabel++;
  3920.                         truejp(node->v.p[0],lab0);
  3921.                         falsejp(node->v.p[1],label);
  3922.                         gen_label(lab0);
  3923.                         break;
  3924.                 case en_not:
  3925.                         truejp(node->v.p[0],label);
  3926.                         break;
  3927.                 default:
  3928.                         siz1 = natural_size(node);    
  3929. if (isintconst(node->nodetype)) {
  3930. if (node->v.i == 0)
  3931.                          gen_code(op_bra,0,make_label(label),0);
  3932.               break;
  3933. }
  3934. else{
  3935. if (siz1 > 4)
  3936.                          ap = gen_expr(node,F_FREG,siz1);
  3937. else
  3938.                          ap = gen_expr(node,F_DREG | F_INDX,siz1);
  3939. }
  3940. if (siz1 > 4) {
  3941.                          gen_codef(op_ftst,siz1,ap,0);
  3942.                          freeop(ap);
  3943.                          gen_code(op_fbeq,0,make_label(label),0);
  3944. }
  3945. else {
  3946.                          gen_code(op_tst,siz1,ap,0);
  3947.                          freeop(ap);
  3948.                          gen_code(op_beq,0,make_label(label),0);
  3949. }
  3950.                         break;
  3951.                 }
  3952. }