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

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

编译器/解释器

开发平台：

Others

GEXPR386.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        "gen386.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 stackadd,stackmod;
  34. extern int prm_largedata, prm_linkreg;
  35. extern AMODE     push[], pop[];
  36. extern int prm_68020;
  37. extern long framedepth, stackdepth;
  38. extern int regs[3];
  39. extern long nextlabel;
  40. extern long lc_maxauto;
  41. extern char regstack[],rsold[],rsodepth,rsdepth;
  42. AMODE freg0[] = { { am_freg, 0 } };
  43. AMODE sreg[] = { { am_dreg,4 } };
  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. void gen_f10code(int op, int size, AMODE *ap1, AMODE *ap2)
  52. {
  53. if (size != 10) 
  54. gen_code(op,size,ap1,ap2);
  55. else {
  56. gen_code(op_fld,size,ap1,ap2);
  57. gen_code(op,size,0,0);
  58. }
  59. }
  60. int chksize(int lsize, int rsize)
  61. {
  62. int l,r;
  63. l = lsize;
  64. r = rsize;
  65. if (l < 0) l = - l;
  66. if (r < 0) r = - r;
  67. return(l > r);
  68. }
  69. AMODE *fstack(void)
  70. {
  71. AMODE *ap = xalloc(sizeof(AMODE));
  72. ap->mode = am_freg;
  73. ap->preg = 0;
  74. ap->sreg = 0;
  75. ap->offset = 0;
  76. ap->tempflag = TRUE;
  77. return(ap);
  78. }
  79. AMODE *make_muldivval(AMODE *ap)
  80. {
  81. int temp;
  82. AMODE *ap1 = make_label(temp = nextlabel++);
  83. queue_muldivval(temp,ap->offset->v.i);
  84. ap1->mode = am_direct;
  85. return(ap1);
  86. }
  87. void make_floatconst(AMODE *ap, int size)
  88. {
  89. int temp;
  90. AMODE *ap1 = make_label(temp = nextlabel++);
  91. if (isintconst(ap->offset->nodetype))
  92. ap->offset->v.f = ap->offset->v.i;
  93. queue_floatval(temp,ap->offset->v.f,size);
  94. ap->mode = am_direct;
  95. ap->length = 8;
  96. ap->offset = ap1->offset;
  97. }
  98. AMODE    *make_label(int lab)
  99. /*
  100.  *      construct a reference node for an internal label number.
  101.  */
  102. {       ENODE    *lnode;
  103.         AMODE    *ap;
  104.         lnode = xalloc(sizeof(ENODE));
  105.         lnode->nodetype = en_labcon;
  106.         lnode->v.i = lab;
  107.         ap = xalloc(sizeof(AMODE));
  108.         ap->mode = am_immed;
  109.         ap->offset = lnode;
  110.         return ap;
  111. }
  113. AMODE    *make_immed(long i)
  114. /*
  115.  *      make a node to reference an immediate value i.
  116.  */
  117. {       AMODE    *ap;
  118.         ENODE    *ep;
  119.         ep = xalloc(sizeof(ENODE));
  120.         ep->nodetype = en_icon;
  121.         ep->v.i = i;
  122.         ap = xalloc(sizeof(AMODE));
  123.         ap->mode = am_immed;
  124.         ap->offset = ep;
  125.         return ap;
  126. }
  127. AMODE    *make_immedt(long i, int size)
  128. /*
  129.  *      make a node to reference an immediate value i.
  130.  */
  131. {
  132. switch (size) {
  133. case 1:
  134. case -1:
  135. i &= 0xff;
  136. break;
  137. case 2:
  138. case -2:
  139. i &= 0xffff;
  140. break;
  141. }
  142. return make_immed(i);
  143. }
  145. AMODE    *make_offset(ENODE *node)
  146. /*
  147.  *      make a direct reference to a node.
  148.  */
  149. {       AMODE    *ap;
  150.         ap = xalloc(sizeof(AMODE));
  151.         ap->mode = am_direct;
  152.         ap->offset = node;
  153.         return ap;
  154. }
  155. AMODE *make_stack(int number)
  156. {
  157. AMODE *ap = xalloc(sizeof(AMODE));        
  158. ENODE *ep = xalloc(sizeof(ENODE));
  159. ep->nodetype = en_icon;
  160. ep->v.i = -number;
  161. ap->mode = am_indisp;
  162. ap->preg = ESP;
  163. ap->offset = ep;
  164. return(ap);
  165. }
  166. void make_legal(AMODE *ap,int flags,int size)
  167. /*
  168.  *      make_legal will coerce the addressing mode in ap1 into a
  169.  *      mode that is satisfactory for the flag word.
  170.  */
  171. {       AMODE    *ap2,*ap1;
  172.         if( ((flags & F_VOL) == 0) || ap->tempflag )
  173.                 {
  174.                 switch( ap->mode )
  175.                         {
  176. case am_freg:
  177. if (flags & F_FREG && size > 4)
  178. return;
  179. break;
  180.                         case am_immed:
  181. if (size > 4) {
  182. make_floatconst(ap,size);
  183.                   if (flags & F_MEM)
  184. return;
  185. }
  186. else
  187.                                  if( flags & F_IMMED )
  188.                                         return;         /* mode ok */
  190.                                 break;
  191.                         case am_dreg:
  192.                                 if( flags & F_DREG) {
  193.                                   return;
  194. }
  195.                                 break;
  196. case am_indisp: case am_indispscale: 
  197. case am_direct:
  198. if (flags & F_INDX)
  199. return;
  200.                                 if( flags & F_MEM)
  201.                                         return;
  202.                                 break;
  203.                         }
  204.                 }
  205. if (!(flags & F_DREG)) {
  206. if (flags & F_FREG && ap->mode != am_freg && !(flags & F_MEM)) {
  207. freeop(ap);
  208. if (size <=4) 
  209. if (size == 1 || size == -1) {
  210. ap1 = temp_data();
  211. if (size < 0)
  212. gen_code2(op_movsx,4,1,ap1,ap);
  213. else
  214. gen_code2(op_movzx,4,1,ap1,ap);
  215. gen_code(op_push,4,ap1,0);
  216. gen_code(op_fild,2,make_stack(0),0);
  217. gen_code(op_add,4,sreg,make_immed(4));
  218. freeop(ap1);
  219. }
  220. else
  221. gen_code(op_fild,size,ap,0);
  222. else
  223. gen_code(op_fld,size,ap,0);
  224. ap->mode = am_freg;
  225. ap->preg = 0;
  226. return;
  227. }
  228. }
  229. else if (size > 4) {
  230. freeop(ap);
  231. gen_code(op_fld,size,ap,0);
  232. if (flags & F_FREG) {
  233. ap->mode = am_freg;
  234. ap->preg = 0;
  235. return;
  236. }
  237. else {
  238. gen_code(op_push,4,makedreg(3),0);
  239. gen_code(op_fistp,4,make_stack(0),0);
  240. ap1 = temp_data();
  241. gen_code(op_pop,4,ap1,make_stack(0));
  242. ap->mode = ap1->mode;
  243. ap->preg = ap1->preg;
  244. return;
  245. }
  246. }
  247.         if( size == -1 )
  248.                 {
  249.                 freeop(ap);
  250.                 ap2 = temp_data();
  251. if (ap->mode == am_immed)
  252.                  gen_code(op_mov,1,ap2,ap);
  253. else if (ap->mode == am_dreg && ap->preg > 3)
  254.                  gen_code(op_mov,4,ap2,ap);
  255. else
  256.                  gen_code2(op_movsx,4,1,ap2,ap);
  257.                 ap->mode = ap2->mode;
  258.                 ap->preg = ap2->preg;
  259. ap->tempflag = TRUE;
  260.                 size = -2;
  261.                 }
  263.         else if( size == 1 )
  264.                 {
  265.                 freeop(ap);
  266.                 ap2 = temp_data();
  267. if (ap->mode == am_immed)
  268.                  gen_code(op_mov,1,ap2,ap);
  269. else if (ap->mode == am_dreg && ap->preg > 3)
  270.                  gen_code(op_mov,4,ap2,ap);
  271. else
  272.                  gen_code2(op_movzx,4,1,ap2,ap);
  273.                 ap->mode = ap2->mode;
  274.                 ap->preg = ap2->preg;
  275. ap->tempflag = TRUE;
  276.                 size = 2;
  277.                 }
  278.         else if( size == -2 )
  279.                 {
  280.                 freeop(ap);
  281.                 ap2 = temp_data();
  282. if (ap->mode == am_immed)
  283.                  gen_code(op_mov,2,ap2,ap);
  284. else if (ap->mode == am_dreg && ap->preg > 3)
  285.                  gen_code(op_mov,4,ap2,ap);
  286. else
  287.                  gen_code2(op_movsx,4,2,ap2,ap);
  288.                 ap->mode = ap2->mode;
  289.                 ap->preg = ap2->preg;
  290. ap->tempflag = TRUE;
  291.                 size = -4;
  292.                 }
  294.         else if( size == 2 )
  295.                 {
  296.                 freeop(ap);
  297.                 ap2 = temp_data();
  298. if (ap->mode == am_immed)
  299.                  gen_code(op_mov,2,ap2,ap);
  300. else if (ap->mode == am_dreg && ap->preg > 3)
  301.                  gen_code(op_mov,4,ap2,ap);
  302. else
  303.                  gen_code2(op_movzx,4,2,ap2,ap);
  304.                 ap->mode = ap2->mode;
  305.                 ap->preg = ap2->preg;
  306. ap->tempflag = TRUE;
  307.                 size = 4;
  308.                 }
  309. else if (size == 4 || size == -4) {
  310.          freeop(ap);
  311.          ap2 = temp_data();
  312.          gen_code(op_mov,size,ap2,ap);
  313.          ap->mode = am_dreg;
  314.          ap->preg = ap2->preg;
  315.          ap->tempflag = 1;
  316. }
  317. }
  318. void bit_legal(AMODE *ap,ENODE *node, int size)
  319. {
  320. if (node->bits != -1) {
  321. make_legal(ap,F_DREG | F_VOL,size);
  322. if (node->startbit)
  323. gen_code(op_shr,size,ap,make_immed(node->startbit));
  324. gen_code(op_and,4,ap,make_immed(bittab[node->bits-1]));
  325. }
  326. }
  327. AMODE *get_bitval(AMODE *ap,ENODE *node, int size)
  328. {
  329. AMODE *ap1 = temp_data();
  330. ap1->tempflag = TRUE;
  331. gen_code(op_mov,size,ap1,ap);
  332. if (node->startbit)
  333. gen_code(op_shr,size,ap1,make_immed(node->startbit));
  334. gen_code(op_and,4,ap1,make_immed(bittab[node->bits-1]));
  335. return ap1;
  336. }
  337. void bit_move(AMODE *ap2, AMODE *ap1, ENODE *node, int flags, int sizein, int sizeout)
  338. {
  339. gen_code(op_and,sizeout,ap2,make_immed(~(bittab[node->bits-1]<<node->startbit)));
  340. if (ap1->mode == am_immed) {
  341. ap1->offset->v.i &= bittab[node->bits-1];
  342. if (ap1->offset->v.i) {
  343. ap1->offset->v.i <<= node->startbit;
  344. gen_code(op_or,sizeout,ap2,ap1);
  345. if (!(flags & F_NOVALUE)) {
  346. make_legal(ap2,flags,sizeout);
  347. ap1->offset->v.i >>= node->startbit;
  348. gen_code(op_mov,sizeout,ap2,ap1);
  349. }
  350. }
  351. }
  352. else {
  353. make_legal(ap1,F_DREG | F_VOL,sizein);
  354. gen_code(op_and,sizein,ap1,make_immed(bittab[node->bits-1]));
  355. if (node->startbit)
  356. gen_code(op_shl,sizein,ap1,make_immed(node->startbit));
  357. gen_code(op_or,sizeout,ap2,ap1);
  358. if (!(flags & F_NOVALUE)) {
  359. if (node->startbit)
  360. gen_code(op_shr,sizein,ap1,make_immed(node->startbit));
  361. }
  362. }
  363. }
  364. void do_extend(AMODE *ap,int isize,int osize,int flags)
  365. /*
  366.  *      if isize is not equal to osize then the operand ap will be
  367.  *      loaded into a register (if not already) and if osize is
  368.  *      greater than isize it will be extended to match.
  369.  */
  370. { AMODE *ap2;
  371. if (isize == 0)
  372. return;
  373.         if( isize == osize || isize == -osize)
  374.                 return;
  375.         if( ap->mode != am_dreg && osize <=4) {
  376. if (flags & F_DEST)
  377.                  make_legal(ap,flags,isize);
  378. else
  379.                  make_legal(ap,F_DREG | F_FREG,isize);
  380. if (flags & F_DEST)
  381. return;
  382. if (chksize(osize,isize))
  383. return;
  384. }
  385. switch(isize)
  386. {
  387. doextend:
  388. case -1:
  389. case 1:
  390.                 case -2:
  391. case 2:
  392. if (osize < isize) {
  393. gen_code2(op_movsx,osize,isize,ap,ap);
  394. }
  395. else if (osize <=4 && osize > isize) {
  396. gen_code2(op_movzx,osize,isize,ap,ap);
  397. }
  398. case 4:
  399. case -4:
  400. do4:
  401. if (osize <= 4)
  402. return;
  403. else {
  404. if (ap->mode != am_freg) {
  405. do_extend(ap,isize,4,F_ALL | F_VOL);
  406. ap2 = make_stack(0);
  407. gen_code(op_push,4,ap,0);
  408. freeop(ap);
  409. gen_codef(op_fild,4,ap2,0);
  410. gen_code(op_add,4,sreg,make_immed(4));
  411. freeop(ap);
  412. }
  413. ap->mode = am_freg;
  414. ap->preg = 0;
  415. ap->tempflag = TRUE;
  416. }
  417. break;
  418. case 6:
  419. case 8:
  420. if (osize > isize) {
  421. if (ap->mode != am_freg) {
  422. gen_codef(op_fld,osize,ap,0);
  423. freeop(ap);
  424. ap->mode = am_freg;
  425. ap->preg = 0;
  426. ap->tempflag = TRUE;
  427. }
  428. return;
  429. }
  431. case 10: 
  432. if (ap->mode != am_freg) {
  433. freeop(ap);
  434. gen_codef(op_fld,isize,ap,0);
  435. ap->mode = am_freg;
  436. ap->preg = 0;
  437. ap->tempflag = TRUE;
  438. }
  439. switch(osize) {
  440. case 1:
  441. case -1:
  442. case 2:
  443. case -2:
  444. case 4:
  445. case -4:
  446. freeop(ap);
  447. ap2 = temp_data();
  448. ap->mode = ap2->mode;
  449. ap->preg = ap2->preg;
  450. gen_code(op_push,4,makedreg(3),0);
  451. gen_codef(op_fistp,4,ap2 = make_stack(0),0);
  452. gen_codef(op_fwait,0,0,0);
  453. gen_code(op_mov,osize,ap,ap2);
  454. gen_code(op_add,4,sreg,make_immed(4));
  455. goto doextend;
  456. case 6:
  457. case 8:
  458. break;
  459. }
  460. }
  461. }
  463. int     isshort(ENODE *node)
  464. /*
  465.  *      return true if the node passed can be generated as a short
  466.  *      offset.
  467.  */
  468. {       return (isintconst(node->nodetype) &&
  469.                 (node->v.i >= -32768L && node->v.i <= 32767L));
  470. }
  472. int     isbyte(ENODE *node)
  473. /*
  474.  *      return true if the node passed can be evaluated as a byte
  475.  *      offset.
  476.  */
  477. {       return isintconst(node->nodetype) &&
  478.                 (-128 <= node->v.i && node->v.i <= 127);
  479. }
  481. AMODE    *gen_index(ENODE *node)
  482. /*
  483.  *      generate code to evaluate an index node (^+) and return
  484.  *      the addressing mode of the result. This routine takes no
  485.  *      flags since it always returns either am_ind or am_indx.
  486.  */
  487. {       AMODE    *ap1,*ap2, *ap, *ap3;
  488. ENODE node2;
  489. int scale;
  491. switch (node->v.p[0]->nodetype) {
  492. case en_icon:
  493. ap1 = gen_expr(node->v.p[0],F_IMMED,4);
  494. break;
  495. case en_lsh:
  496. if ((scale = node->v.p[0]->v.p[1]->v.i) < 4 && scale) {
  497. ap1 = gen_expr(node->v.p[0]->v.p[0],F_IMMED | F_DREG,4);
  498. if (ap1->mode == am_immed) {
  499. while (--scale)
  500. ap1->offset->v.i <<=1;
  501. }
  502. else {
  503. ap1->mode = am_indispscale;
  504. ap1->sreg = ap1->preg;
  505. ap1->preg = -1;
  506. ap1->scale = scale;
  507. ap1->offset = makenode(en_icon,0,0);
  508. }
  509. break;
  510. }
  511. default:
  512. mark();
  513. ap1 = gen_deref(node,F_MEM | F_DREG,4);
  514. switch (ap1->mode) {
  515. default:
  516. rsold[rsodepth-1] = rsdepth;
  517. break;
  518. case am_indispscale:
  519. if (ap1->sreg >=0 && ap1->preg >= 0) {
  520. int t = rsold[rsodepth-1];
  521. freeop(ap1);
  522. ap3 = temp_data();
  523. gen_code(op_lea,4,ap3,ap1);
  524. ap3->mode = am_indisp;
  525. ap3->offset = makenode(en_icon,0,0);
  526. if (t <rsdepth-1 && ap3->preg + 8 == regstack[t+1])
  527. t+=2;
  528. if (t <rsdepth && ap3->preg + 8 == regstack[t])
  529. t+=1;
  530. ap1 = ap3;
  531. }
  533. }
  534. release();
  535. break;
  536. }
  537. switch (node->v.p[1]->nodetype) {
  538. case en_icon:
  539. ap2 = gen_expr(node->v.p[1],F_IMMED,4);
  540. break;
  541. case en_lsh:
  542. if ((scale = node->v.p[1]->v.p[1]->v.i) < 4 && scale) {
  543. ap2 = gen_expr(node->v.p[1]->v.p[0],F_IMMED | F_DREG,4);
  544. if (ap2->mode == am_immed) {
  545. while (--scale)
  546. ap2->offset->v.i <<=1;
  547. }
  548. else {
  549. ap2->mode = am_indispscale;
  550. ap2->sreg = ap2->preg;
  551. ap2->preg = -1;
  552. ap2->scale = scale;
  553. ap2->offset = makenode(en_icon,0,0);
  554. }
  555. break;
  556. }
  557. default:
  558. node2.v.p[0] = node->v.p[1];
  559. node2.nodetype = node->nodetype;
  560. mark();
  561. ap2 = gen_deref(&node2,F_MEM | F_DREG,4);
  562. switch (ap1->mode) {
  563. default:
  564. rsold[rsodepth-1] = rsdepth;
  565. break;
  566. case am_indispscale:
  567. if (ap1->sreg >=0 && ap1->preg >= 0) {
  568. int t = rsold[rsodepth-1];
  569. freeop(ap1);
  570. ap3 = temp_data();
  571. gen_code(op_lea,4,ap3,ap1);
  572. ap3->mode = am_indisp;
  573. ap3->offset = makenode(en_icon,0,0);
  574. if (t <rsdepth-1 && ap3->preg + 8 == regstack[t+1])
  575. t+=2;
  576. if (t <rsdepth && ap3->preg + 8 == regstack[t])
  577. t+=1;
  578. ap1 = ap3;
  579. }
  581. }
  582. release();
  583. break;
  584. }
  585. switch(ap1->mode) {
  586. case am_dreg:
  587. switch (ap2->mode) {
  588. case am_dreg:
  589. ap1->sreg = ap2->preg;
  590. ap1->scale = 0;
  591. ap1->mode = am_indispscale;
  592. ap1->offset = makenode(en_icon,(char *)0,0);
  593. return ap1;
  594. case am_immed:
  595. case am_direct:
  596. ap2->preg = ap1->preg;
  597. ap2->mode = am_indisp;
  598. return ap2;
  599. case am_indisp:
  600. ap2->sreg = ap2->preg;
  601. ap2->preg = ap1->preg;
  602. ap2->mode = am_indispscale;
  603. ap2->offset = ap1->offset;
  604. ap2->scale = 0;
  605. return ap2;
  606. case am_indispscale:
  607. if (ap2->preg == -1) {
  608. ap2->preg = ap1->preg;
  609. return ap2;
  610. }
  611. freeop(ap2);
  612. ap = temp_data();
  613. gen_code(op_lea,4,ap,ap2);
  614. ap->sreg = ap1->preg;
  615. ap->mode = am_indispscale;
  616. ap->scale = 0;
  617. ap->offset = makenode(en_icon,0,0);
  618. return ap;
  619. }
  620. break;
  621. case am_direct:
  622. case am_immed:
  623. switch (ap2->mode) {
  624. case am_dreg:
  625. ap2->mode = am_indisp;
  626. ap2->offset = ap1->offset;
  627. return ap2;
  628. case am_immed:
  629. case am_direct:
  630. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  631. ap1->offset->v.i += ap2->offset->v.i;
  632. else
  633. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  634.   ap1->mode = am_direct;
  635. return ap1;
  636. case am_indisp:
  637. case am_indispscale:
  638. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  639. ap2->offset->v.i += ap1->offset->v.i;
  640. else
  641. ap2->offset = makenode(en_add,ap1->offset,ap2->offset);
  642. return ap2;
  643. }
  644. break;
  645. case am_indisp:
  646. switch (ap2->mode) {
  647. case am_dreg:
  648. ap1->mode = am_indispscale;
  649. ap1->sreg = ap2->preg;
  650. ap1->scale = 0;
  651. return ap1;
  652. case am_immed:
  653. case am_direct:
  654. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  655. ap1->offset->v.i += ap2->offset->v.i;
  656. else
  657. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  658. return ap1;
  659. case am_indisp:
  660. ap1->mode = am_indispscale;
  661. ap1->sreg = ap2->preg;
  662. ap1->scale = 0;
  663. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  664. ap1->offset->v.i += ap2->offset->v.i;
  665. else
  666. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  667. return ap1;
  668. case am_indispscale:
  669. if (ap2->preg == -1) {
  670. ap2->preg = ap1->preg;
  671. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  672. ap2->offset->v.i += ap1->offset->v.i;
  673. else
  674. ap2->offset = makenode(en_add,ap1->offset,ap2->offset);
  675. return ap2;
  676. }
  677. freeop(ap2);
  678. ap = temp_data();
  679. gen_code(op_lea,4,ap,ap2);
  680. ap1->sreg = ap->preg;
  681. ap1->scale = 0;
  682. ap1->mode = am_indispscale;
  683. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  684. ap1->offset->v.i += ap2->offset->v.i;
  685. else
  686. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  687. return ap1;
  688. }
  689. break;
  690. case am_indispscale:
  691. switch (ap2->mode) {
  692. case am_dreg:
  693. if (ap1->preg == -1) {
  694. ap1->preg = ap2->preg;
  695. return ap1;
  696. }
  697. freeop(ap1);
  698. ap = temp_data();
  699. gen_code(op_lea,4,ap,ap1);
  700. ap->sreg = ap2->preg;
  701. ap->scale = 0;
  702. ap->offset = ap1->offset;
  703. return ap;
  704. case am_immed:
  705. case am_direct:
  706. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  707. ap1->offset->v.i += ap2->offset->v.i;
  708. else
  709. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  710. return ap1;
  711. case am_indisp:
  712. if (ap1->preg == -1) {
  713. ap1->preg = ap2->preg;
  714. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  715. ap1->offset->v.i += ap2->offset->v.i;
  716. else
  717. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  718. return ap1;
  719. }
  720. freeop(ap1);
  721. ap = temp_data();
  722. gen_code(op_lea,4,ap,ap1);
  723. ap->sreg = ap2->preg;
  724. ap->scale = 0;
  725. ap->mode = am_indispscale;
  726. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  727. ap->offset->v.i = ap2->offset->v.i +ap1->offset->v.i;
  728. else
  729. ap->offset = makenode(en_add,ap1->offset,ap2->offset);
  730. return ap;
  731. case am_indispscale:
  732. if (ap1->preg == -1 && ap2->preg == -1) {
  733. if (ap1->scale == 0) {
  734. ap2->preg = ap1->sreg;
  735. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  736. ap2->offset->v.i += ap1->offset->v.i;
  737. else
  738. ap2->offset = makenode(en_add,ap1->offset,ap2->offset);
  739. return ap2;
  740. } else if (ap2->scale == 0) {
  741. ap1->preg = ap2->sreg;
  742. if (ap1->offset->nodetype == en_icon && ap2->offset->nodetype == en_icon)
  743. ap1->offset->v.i += ap2->offset->v.i;
  744. else
  745. ap1->offset = makenode(en_add,ap1->offset,ap2->offset);
  746. return ap1;
  747. }
  748. }
  749. if (ap1->preg == -1) {
  750. freeop(ap2);
  751. ap = temp_data();
  752. gen_code(op_lea,4,ap,ap2);
  753. ap1->preg = ap->preg;
  754. return ap1;
  755. }
  756. else if (ap2->preg == -1) {
  757. freeop(ap1);
  758. ap = temp_data();
  759. gen_code(op_lea,4,ap,ap1);
  760. ap2->preg = ap->preg;
  761. return ap2;
  762. }
  763. freeop(ap1);
  764. ap = temp_data();
  765. gen_code(op_lea,4,ap,ap1);
  766. freeop(ap2);
  767. ap1 = temp_data();
  768. gen_code(op_lea,4,ap1,ap2);
  769. ap->mode = am_indispscale;
  770. ap->sreg = ap1->preg;
  771. ap->scale = 0;
  772. ap->offset = makenode(en_icon,0,0);
  773. return ap;
  774. }
  775. break;           
  776. }
  777. DIAG("invalid index conversion");
  778. }
  780. AMODE    *gen_deref(ENODE *node, int flags,int size)
  781. /*
  782.  *      return the addressing mode of a dereferenced node.
  783.  */
  784. {       AMODE    *ap1;
  785.         int             ssize,psize;
  786. psize = size;
  787. if (psize < 0)
  788. psize = - psize;
  789.         switch( node->nodetype )        /* get load size */
  790.                 {
  791.                 case en_ub_ref:
  792.                         ssize = 1;
  793.                         break;
  794.                 case en_b_ref:
  795.                         ssize = -1;
  796.                         break;
  797.                 case en_uw_ref:
  798.                         ssize = 2;
  799.                         break;
  800.                 case en_w_ref:
  801.                         ssize = -2;
  802.                         break;
  803.                 case en_l_ref:
  804. ssize = -4;
  805. break;
  806. case en_ul_ref:
  807.                         ssize = 4;
  808.                         break;
  809. case en_floatref:
  810. ssize = 6;
  811. break;
  812. case en_doubleref:
  813. ssize = 8;
  814. break;
  815. case en_longdoubleref:
  816. ssize = 10;
  817. break;
  818. default:
  819. ssize = 4;
  820.                 }
  821.         if( node->v.p[0]->nodetype == en_add )
  822.                 {
  823.                 ap1 = gen_index(node->v.p[0]);
  824.                 do_extend(ap1,ssize,psize,flags);
  825.                 make_legal(ap1,flags,psize);
  826.                 return ap1;
  827.                 }
  828.         else if( node->v.p[0]->nodetype == en_autocon  || node->v.p[0]->nodetype == en_autoreg)
  829.                 {
  830.                 ap1 = xalloc(sizeof(AMODE));
  831.                 ap1->mode = am_indisp;
  832. ap1->preg = ESP;
  833. if (prm_linkreg) {
  834.            ap1->preg = EBP;
  835.             ap1->offset = makenode(en_icon,(char *)((SYM *)node->v.p[0]->v.p[0])->value.i,0);
  836. }
  837. else if (((SYM *)node->v.p[0]->v.p[0])->funcparm)
  838.                  ap1->offset = makenode(en_icon,(char *)(((SYM *)node->v.p[0]->v.p[0])->value.i+framedepth+stackdepth),0);
  839.                 else
  840. ap1->offset = makenode(en_icon,(char *)(((SYM *)node->v.p[0]->v.p[0])->value.i+stackdepth+lc_maxauto),0);
  841.                 do_extend(ap1,ssize,size,flags);
  842.                 make_legal(ap1,flags,psize);
  843.                 return ap1;
  844.                 }
  845.         else if( node->v.p[0]->nodetype == en_nacon || node->v.p[0]->nodetype == en_napccon)
  846.                 {
  847.                 ap1 = xalloc(sizeof(AMODE));
  848.                 ap1->offset = makenode(node->v.p[0]->nodetype,(char *)((SYM *)node->v.p[0]->v.p[0])->name,0);
  849.                 ap1->mode = am_direct;
  850.                 do_extend(ap1,ssize,size,flags);
  851.                 make_legal(ap1,flags,psize);
  852.                 return ap1;
  853.                 }
  854.         else if( node->v.p[0]->nodetype == en_nalabcon)
  855.                 {
  856.                 ap1 = xalloc(sizeof(AMODE));
  857.                 ap1->offset = makenode(node->v.p[0]->nodetype,(char *)node->v.p[0]->v.i,0);
  858.                 ap1->mode = am_direct;
  859.                 do_extend(ap1,ssize,size,flags);
  860.                 make_legal(ap1,flags,psize);
  861.                 return ap1;
  862.                 }
  863.         else if( node->v.p[0]->nodetype == en_labcon)
  864.                 {
  865.                 ap1 = xalloc(sizeof(AMODE));
  866.                 ap1->mode = am_direct;
  867.                 ap1->offset = makenode(node->v.p[0]->nodetype,(char *)node->v.p[0]->v.i,0);
  868.                 do_extend(ap1,ssize,size,flags);
  869.                 make_legal(ap1,flags,psize);
  870.                 return ap1;
  871.                 }
  872. else if (node->v.p[0]->nodetype == en_absacon) {
  873. ap1 = xalloc(sizeof(AMODE));
  874. ap1->mode = am_direct;
  875. ap1->offset = makenode(en_absacon,(char *)((SYM *)node->v.p[0]->v.p[0])->value.i,0);
  876.                 do_extend(ap1,ssize,size,flags);
  877.                 make_legal(ap1,flags,psize);
  878.                 return ap1;
  880. }
  881. else if (node->v.p[0]->nodetype == en_regref) {
  882.          ap1 = gen_expr(node->v.p[0],F_ALL,4);
  883.           do_extend(ap1,ssize,size,flags);
  884.           make_legal(ap1,flags,psize);
  885. return ap1;
  886. }
  887.         ap1 = gen_expr(node->v.p[0],F_DREG | F_IMMED,4); /* generate address */
  888.         if( ap1->mode == am_dreg )
  889.                 {
  890.                 ap1->mode = am_indisp;
  891. ap1->offset = makenode(en_icon,0,0);
  892.            do_extend(ap1,ssize,size,flags);
  893.          make_legal(ap1,flags,psize);
  894.                 return ap1;
  895.                 }
  896.         ap1->mode = am_direct;
  897.         do_extend(ap1,ssize,size,flags);
  898.         make_legal(ap1,flags,psize);
  899.         return ap1;
  900. }
  902. AMODE    *gen_unary(ENODE *node,int flags,int size,int op, int fop)
  903. /*
  904.  *      generate code to evaluate a unary minus or complement.
  905.  */
  906. {       AMODE    *ap;
  907.         ap = gen_expr(node->v.p[0],F_FREG | F_DREG | F_VOL,size);
  908. if (ap->mode == am_freg) {
  909. gen_code(fop,0,0,0);
  910. ap = fstack();
  911. }
  912. else {
  913.          gen_code(op,size,ap,0);
  914. }
  915.         make_legal(ap,flags,size);
  916.         return ap;
  917. }
  919. AMODE    *gen_binary(ENODE *node,int flags,int size,int op, int fop)
  920. /*
  921.  *      generate code to evaluate a binary node and return 
  922.  *      the addressing mode of the result.
  923.  */
  924. {       AMODE    *ap1, *ap2;
  925. if (size > 4) {
  926.          ap1 = gen_expr(node->v.p[0],F_VOL | F_FREG,size);
  927. mark();
  928.          ap2 = gen_expr(node->v.p[1],F_MEM | F_FREG,size);
  929. if (ap2->mode == am_freg)
  930. gen_code(fop,0,0,0);
  931. else {
  932. int t;
  933. t = natural_size(node->v.p[1]);
  934. if (t== 0) t = size;
  935. if (t <=4)
  936. if (fop == op_fadd)
  937. fop = op_fiadd;
  938. else
  939. fop = op_fisub;
  940. gen_f10code(fop,t,ap2,0);
  941. }
  942. ap1 = fstack();
  943. }
  944. else {
  945.          ap1 = gen_expr(node->v.p[0],F_VOL | F_DREG,size);
  946. mark();
  947.          ap2 = gen_expr(node->v.p[1],F_ALL,size);
  948.          gen_code(op,size,ap1,ap2);
  949. }
  950.         freeop(ap2);
  951. release();
  952.         make_legal(ap1,flags,size);
  953.         return ap1;
  954. }
  956. AMODE    *gen_xbin(ENODE *node,int flags,int size,int op, int fop)
  957. /*
  958.  *      generate code to evaluate a restricted binary node and return 
  959.  *      the addressing mode of the result.
  960.  */
  961. {       AMODE    *ap1, *ap2;
  962. if (size > 4) {
  963.          ap1 = gen_expr(node->v.p[0],F_VOL | F_FREG,size);
  964. mark();
  965.          ap2 = gen_expr(node->v.p[1],F_MEM | F_FREG,size);
  966. if (ap2->mode == am_freg)
  967. gen_code(fop,0,0,0);
  968. else
  969. gen_code(fop,size,ap2,0);
  970. ap1 = fstack();
  971. }
  972. else {
  973.          ap1 = gen_expr(node->v.p[0],F_VOL | F_DREG,size);
  974. mark();
  975.          ap2 = gen_expr(node->v.p[1],F_ALL,size);
  976.          gen_code(op,size,ap2,ap1);
  977. }
  978. release();
  979.         freeop(ap2);
  980.         make_legal(ap1,flags,size);
  981.         return ap1;
  982. }
  983. void doshift(AMODE *ap1, AMODE *ap2, int size, int op)
  984. {       AMODE   *ecx = makedreg(ECX), *eax = makedreg(EAX);
  985. if (ap2->mode == am_immed) {
  986. gen_code2(op,size,1,ap1,ap2);
  987. }
  988. else
  989. if (ap1->mode == am_dreg && ap1->preg == ECX) {
  990. if (ap2->mode == am_dreg) {
  991. gen_code(op_xchg,4,ap2,ap1);
  992. gen_code2(op,size,1,ap2,ecx);
  993. gen_code(op_xchg,4,ap2,ap1);
  994. }
  995. else {
  996. if (regs[0])
  997. gen_push(EAX,am_dreg,0);
  998. gen_code(op_xchg,4,eax,ecx);
  999. gen_code(op_mov,1,ap2,ecx);
  1000. gen_code2(op,size,1,eax,ecx);
  1001. gen_code(op_xchg,4,eax,ecx);
  1002. if (regs[0])
  1003. gen_pop(EAX,am_dreg,0);
  1004. }
  1005. }
  1006. else
  1007. if (ap2->mode == am_dreg) {
  1008. if (ap2->preg != ECX)
  1009. gen_code(op_xchg,4,ap2,ecx);
  1010. gen_code2(op,size,1,ap1,ecx);
  1011. if (ap2->preg != ECX)
  1012. gen_code(op_xchg,4,ap2,ecx);
  1013. }
  1014. else {
  1015. if (regs[1])
  1016. gen_push(ECX,am_dreg,0);
  1017. gen_code(op_mov,4,ap2,ecx);
  1018. gen_code2(op,size,1,ap1,ecx);
  1019. if (regs[1])
  1020. gen_pop(ECX,am_dreg,0);
  1021. }
  1022. }
  1023. AMODE    *gen_shift(ENODE *node, int flags, int size, int op)
  1024. /*
  1025.  *      generate code to evaluate a shift node and return the
  1026.  *      address mode of the result.
  1027.  */
  1028. {       AMODE    *ap1, *ap2;
  1029.         ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,size);
  1030. mark();
  1031.         ap2 = gen_expr(node->v.p[1],F_DREG | F_IMMED,natural_size(node->v.p[1]));
  1032. doshift(ap1,ap2,size,op);
  1033.         freeop(ap2);
  1034. release();
  1035.         make_legal(ap1,flags,size);
  1036.         return ap1;
  1037. }
  1038. void dodiv(AMODE *ap1, AMODE *ap2, int size, int op,int modflag)
  1039. {
  1040. AMODE *eax = makedreg(EAX), *edx = makedreg(EDX), *ecx = makedreg(ECX);
  1041. if (ap2->mode == am_immed) {
  1042. ap2 = make_muldivval(ap2);
  1043. }
  1044. if (ap1->preg != EAX) {
  1045. int temp;
  1046. gen_code(op_xchg,4,eax,ap1);
  1047. if (ap1->mode == am_dreg && ap2->mode == am_dreg && ap1->preg == ap2->preg) {
  1048. gen_code(op,4,eax,0);
  1049. gen_code(op_xchg,4,eax,ap1);
  1050. return;
  1051. }
  1052. temp = regs[0];
  1053. regs[0] = regs[ap1->preg];
  1054. regs[ap1->preg] = temp;
  1055. }
  1056. if (ap2->preg == EDX) {
  1057. if (regs[1])
  1058. gen_push(ECX,am_dreg,0);
  1059. if (regs[2])
  1060. gen_push(EDX,am_dreg,0);
  1061. gen_code(op_mov,4,ecx,edx);
  1062. gen_code(op_sub,4,edx,edx);
  1063. gen_code(op,4,ecx,0);
  1064. if (modflag)
  1065. gen_code(op_xchg,4,eax,edx);
  1066. if (regs[2])
  1067. gen_pop(EDX,am_dreg,0);
  1068. if (regs[1])
  1069. gen_pop(ECX,am_dreg,0);
  1070. }
  1071. else {
  1072. if (regs[2])
  1073. gen_push(EDX,am_dreg,0);
  1074. gen_code(op_sub,4,edx,edx);
  1075. gen_code(op,4,ap2,0);
  1076. if (modflag)
  1077. gen_code(op_xchg,4,eax,edx);
  1078. if (regs[2])
  1079. gen_pop(EDX,am_dreg,0);
  1080. }
  1081. if (ap1->preg != EAX) {
  1082. int temp;
  1083. gen_code(op_xchg,4,eax,ap1);
  1084. temp = regs[0];
  1085. regs[0] = regs[ap1->preg];
  1086. regs[ap1->preg] = temp;
  1087. }
  1088. }
  1089. void domul(AMODE *ap1, AMODE *ap2, int size, int op)
  1090. {
  1091. AMODE *eax = makedreg(EAX), *edx = makedreg(EDX), *ecx = makedreg(ECX);
  1092. if (ap2->mode == am_immed) {
  1093. ap2 = make_muldivval(ap2);
  1094. }
  1095. if (ap1->preg != EAX) {
  1096. int temp;
  1097. gen_code(op_xchg,4,eax,ap1);
  1098. if (ap1->mode == am_dreg && ap2->mode == am_dreg && ap1->preg == ap2->preg && ap1->preg != EDX) {
  1099. gen_code(op,4,eax,0);
  1100. gen_code(op_xchg,4,eax,ap1);
  1101. return;
  1102. }
  1103. temp = regs[0];
  1104. regs[0] = regs[ap1->preg];
  1105. regs[ap1->preg] = temp;
  1106. }
  1107. if (ap2->preg == EDX) {
  1108. if (regs[1])
  1109. gen_push(ECX,am_dreg,0);
  1110. if (regs[2])
  1111. gen_push(EDX,am_dreg,0);
  1112. gen_code(op_mov,4,ecx,edx);
  1113. gen_code(op_sub,4,edx,edx);
  1114. gen_code(op,4,ecx,0);
  1115. if (regs[2])
  1116. gen_pop(EDX,am_dreg,0);
  1117. if (regs[1])
  1118. gen_pop(ECX,am_dreg,0);
  1119. }
  1120. else {
  1121. if (regs[2])
  1122. gen_push(EDX,am_dreg,0);
  1123. gen_code(op,4,ap2,0);
  1124. if (regs[2])
  1125. gen_pop(EDX,am_dreg,0);
  1126. }
  1127. if (ap1->preg != EAX) {
  1128. int temp;
  1129. gen_code(op_xchg,4,eax,ap1);
  1130. temp = regs[0];
  1131. regs[0] = regs[ap1->preg];
  1132. regs[ap1->preg] = temp;
  1133. }
  1134. }
  1135. AMODE    *gen_modiv(ENODE *node, int flags, int size, int op, int modflag)
  1136. /*
  1137.  *      generate code to evaluate a mod operator or a divide
  1138.  *      operator. these operations are done on only long
  1139.  *      divisors and word dividends so that the 68000 div
  1140.  *      instruction can be used.
  1141.  */
  1142. {       AMODE    *ap1, *ap2;
  1144. if (size > 4) {
  1145. ap1 = gen_expr(node->v.p[0],F_FREG | F_VOL,size);
  1146. ap2 = gen_expr(node->v.p[1],F_ALL,size);
  1147. op = op_fdiv;
  1148. if (ap2->mode == am_freg)
  1149. gen_code(op,0,0,0);
  1150. else {
  1151. int t;
  1152. t = natural_size(node->v.p[1]);
  1153. if (t== 0) t = size;
  1154. if (t <=4)
  1155. op = op_fidiv;
  1156. gen_f10code(op,t,ap2,0);
  1157. }
  1158. ap1 = fstack();
  1159. do_extend(ap1,10,size,flags);
  1160. make_legal(ap1,flags,size);
  1161. return ap1;
  1162. }
  1163. if (op == op_idiv) {
  1164.           ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,-4);
  1165. }
  1166. else {
  1167.          ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,4);
  1168. }
  1169. mark();
  1170. if (op == op_idiv) {
  1171.           ap2 = gen_expr(node->v.p[1],F_ALL,-4);
  1172. }
  1173. else {
  1174.          ap2 = gen_expr(node->v.p[1],F_ALL,4);
  1175. }
  1176. dodiv(ap1,ap2,size,op,modflag);
  1177. freeop(ap2);
  1178. release();
  1179.          make_legal(ap1,flags,size);
  1180.          return ap1;
  1182. }
  1185. void swap_nodes(ENODE *node)
  1186. /*
  1187.  *      exchange the two operands in a node.
  1188.  */
  1189. {       ENODE    *temp;
  1190.         temp = node->v.p[0];
  1191.         node->v.p[0] = node->v.p[1];
  1192.         node->v.p[1] = temp;
  1193. }
  1195. AMODE * gen_pdiv(ENODE *node, int flags, int size)
  1196. {
  1197. return gen_modiv(node,flags,size,op_div,FALSE);
  1198. }
  1199. AMODE * gen_pmul(ENODE *node, int flags, int size)
  1200. {
  1201. return gen_mul(node,flags,size,op_mul);
  1202. }
  1203. AMODE    *gen_mul(ENODE *node, int flags, int size, int op)
  1204. /*
  1205.  *      generate code to evaluate a multiply node. both operands
  1206.  *      are treated as words and the result is long and is always
  1207.  *      in a register so that the 68000 mul instruction can be used.
  1208.  */
  1209. {       AMODE    *ap1, *ap2;
  1211. if (isintconst(node->v.p[0]->nodetype))
  1212. swap_nodes(node);
  1213. if (size > 4) {
  1214. ap1 = gen_expr(node->v.p[0],F_FREG | F_VOL,size);
  1215. ap2 = gen_expr(node->v.p[1],F_ALL,size);
  1216. op = op_fmul;
  1217. if (ap2->mode == am_freg)
  1218. gen_code(op,0,0,0);
  1219. else {
  1220. int t;
  1221. t = natural_size(node->v.p[1]);
  1222. if (t== 0) t = size;
  1223. if (t <=4)
  1224. op = op_fimul;
  1225. gen_f10code(op,t,ap2,0);
  1226. }
  1227. ap1 = fstack();
  1228. do_extend(ap1,10,size,flags);
  1229. make_legal(ap1,flags,size);
  1230. return ap1;
  1231. }
  1232. if (op == op_imul) {
  1233.           ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,-4);
  1234. }
  1235. else {
  1236.          ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,4);
  1237. }
  1238. mark();
  1239. if (op == op_imul) {
  1240.           ap2 = gen_expr(node->v.p[1],F_ALL,-4);
  1241. }
  1242. else {
  1243.          ap2 = gen_expr(node->v.p[1],F_ALL,4);
  1244. }
  1245. domul(ap1,ap2,size,op);
  1246. freeop(ap2);
  1247. release();
  1248. do_extend(ap1,4,size,flags);
  1249.          make_legal(ap1,flags,size);
  1250.          return ap1;
  1251. }
  1252. AMODE    *gen_hook(ENODE *node, int flags, int size)
  1253. /*
  1254.  *      generate code to evaluate a condition operator node (?:)
  1255.  */
  1256. {       AMODE    *ap1, *ap2;
  1257.         int             false_label, end_label;
  1258.         false_label = nextlabel++;
  1259.         end_label = nextlabel++;
  1260.         flags = (flags & (F_AREG | F_DREG)) | F_VOL;
  1261.         falsejp(node->v.p[0],false_label);
  1262.         node = node->v.p[1];
  1263.         ap1 = gen_expr(node->v.p[0],flags,size);
  1264.         freeop(ap1);
  1265.         gen_code(op_jmp,0,make_label(end_label),0);
  1266.         gen_label(false_label);
  1267.         ap2 = gen_expr(node->v.p[1],flags,size);
  1268.         if( !equal_address(ap1,ap2) )
  1269.                 {
  1270.                 freeop(ap2);
  1271.                 temp_data();
  1272.                 gen_code(op_mov,size,ap2,ap1);
  1273.                 }
  1274.         gen_label(end_label);
  1275.         return ap1;
  1276. }
  1278. void floatstore(AMODE *ap, int size, int flags)
  1279. {
  1280. if (size <= 4)
  1281. if (flags & F_NOVALUE)
  1282.   gen_codef(op_fistp,size,ap,0);
  1283. else
  1284.   gen_codef(op_fist,size,ap,0);
  1285. else
  1286. if (flags & F_NOVALUE)
  1287.   gen_codef(op_fstp,size,ap,0);
  1288. else
  1289.   gen_codef(op_fst,size,ap,0);
  1290. }
  1291. AMODE    *gen_asadd(ENODE *node, int flags, int size, int op, int fop)
  1292. /*
  1293.  *      generate a plus equal or a minus equal node.
  1294.  */
  1295. {       AMODE    *ap1, *ap2, *ap3;
  1296.         int             ssize,rsize;
  1297.         ssize = natural_size(node->v.p[0]);
  1298.         rsize = natural_size(node->v.p[1]);
  1299. if (rsize == 0)
  1300. rsize = ssize;
  1301. if (rsize > 4) {
  1302. ap2 = gen_expr(node->v.p[0],F_FREG,rsize);
  1303. ap3 = gen_expr(node->v.p[0],F_MEM,ssize);
  1304. ap1 = gen_expr(node->v.p[1],F_FREG | F_MEM,rsize);
  1305. if (ap1->mode == am_freg)
  1306. gen_code(fop,0,0,0);
  1307. else {
  1308. if (rsize <= 4)
  1309. if (fop == op_fadd)
  1310. fop = op_fiadd;
  1311. else
  1312. fop = op_fisub;
  1313. gen_f10code(fop,rsize,ap1,0);
  1314. }
  1315. floatstore(ap3,ssize,flags);
  1316. gen_codef(op_fwait,0,0,0);
  1317. if (!(flags & F_NOVALUE)) {
  1318. ap2 = fstack();
  1319. do_extend(ap2,ssize,size,flags);
  1320. make_legal(ap2,flags,size);
  1321. }
  1322. return ap2;
  1323. }
  1324.         if (chksize( ssize ,rsize ))
  1325.                 rsize = ssize;
  1326.          ap2 = gen_expr(node->v.p[0],F_ALL | F_NOBIT | F_DEST,ssize);
  1327. mark();
  1328.         ap1 = gen_expr(node->v.p[1],F_DREG | F_IMMED,rsize);
  1329. if (node->v.p[0]->nodetype == en_bits)
  1330. ap3= get_bitval(ap2,node->v.p[0],ssize);
  1331. if (node->v.p[0]->nodetype == en_bits) {
  1332. gen_code(op,ssize,ap3,ap1);
  1333. bit_move(ap2,ap3,node->v.p[0],flags, ssize,rsize);
  1334. freeop(ap3);
  1335. }
  1336. else
  1337.         gen_code(op,ssize,ap2,ap1);
  1338. freeop(ap1);
  1339. release();
  1340. if (flags & F_NOVALUE)
  1341. freeop(ap2);
  1342. else {
  1343. do_extend(ap2,ssize,size,flags);
  1344.         make_legal(ap2,flags,4);
  1345. }
  1346.         return ap2;
  1347. }
  1349. AMODE    *gen_aslogic(ENODE *node, int flags, int size, int op)
  1350. /*
  1351.  *      generate a and equal or a or equal node.
  1352.  */
  1353. {       AMODE    *ap1, *ap2;
  1354.         int             ssize,rsize;
  1355.         ssize = natural_size(node->v.p[0]);
  1356.         rsize = natural_size(node->v.p[1]);
  1357.         if (chksize( ssize , rsize ))
  1358.                 rsize = ssize;
  1360.          ap2 = gen_expr(node->v.p[0],F_ALL | F_NOBIT | F_DEST,ssize);
  1361. mark();
  1362.         ap1 = gen_expr(node->v.p[1],F_DREG | F_IMMED,rsize);
  1363. if (node->v.p[0]->nodetype == en_bits) {
  1364. if (ap1->mode == am_immed) {
  1365. ap1->offset->v.i &= bittab[node->v.p[0]->bits-1];
  1366. ap1->offset->v.i <<= node->v.p[0]->startbit;
  1367. gen_code(op,ssize,ap2,ap1);
  1368. }
  1369. else {
  1370.   gen_code(op_and,ssize,ap1,make_immed(bittab[node->v.p[0]->bits-1]));
  1371. if (node->v.p[0]->startbit)
  1372.    gen_code(op_shl,ssize,ap1,make_immed(node->v.p[0]->startbit));
  1373. gen_code(op,ssize,ap2,ap1);
  1374. if (!(flags & F_NOVALUE)) {
  1375. freeop(ap1);
  1376. release();
  1377. if (node->v.p[0]->startbit)
  1378.    gen_code(op_shr,ssize,ap2,make_immed(node->v.p[0]->startbit));
  1379.          do_extend(ap2,ssize,size,0);
  1380. make_legal(ap2,F_DREG,size);
  1381. return(ap2);
  1382. }
  1383. }
  1384. }
  1385. else
  1386.          gen_code(op,ssize,ap2,ap1);
  1387. freeop(ap1);
  1388. release();
  1389. if (flags & F_NOVALUE)
  1390. freeop(ap2);
  1391. else {
  1392. do_extend(ap2,ssize,size,flags);
  1393.          make_legal(ap2,flags,4);
  1394. }
  1395.         return ap2;
  1396. }
  1398. AMODE *gen_asshift(ENODE *node, int flags, int size, int op)
  1399. /*
  1400.  *      generate shift equals operators.
  1401.  */
  1402. {       
  1403.         AMODE    *ap1, *ap2, *ap3;
  1404.         int ssize = natural_size(node->v.p[0]);
  1405.         int rsize = natural_size(node->v.p[1]);
  1406.         if (chksize( ssize , rsize ))
  1407.                 rsize = rsize;
  1408.          ap2 = gen_expr(node->v.p[0],F_ALL | F_NOBIT | F_DEST,ssize);
  1409. mark();
  1410.         ap1 = gen_expr(node->v.p[1],F_DREG | F_IMMED,rsize);
  1411. if (node->v.p[0]->nodetype == en_bits)
  1412. ap3 = get_bitval(ap2,node->v.p[0],ssize);
  1413. else
  1414. ap3 = ap2;
  1416. doshift(ap3,ap1,ssize,op);
  1417. if (node->v.p[0]->nodetype == en_bits)
  1418. bit_move(ap2,ap3,node->v.p[0],flags,ssize,rsize);
  1419. freeop(ap1);
  1420. release();
  1421. if (ap3 != ap1)
  1422. freeop(ap3);
  1423. if (flags & F_NOVALUE)
  1424. freeop(ap2);
  1425. else {
  1426. do_extend(ap2,ssize,size,flags);
  1427.         make_legal(ap2,flags,4);
  1428. }
  1429.          return ap2;
  1430. }
  1432. AMODE    *gen_asmul(ENODE *node, int flags, int size,int op)
  1433. /*
  1434.  *      generate a *= node.
  1435.  */
  1436. {       AMODE    *ap1, *ap2,*ap3;
  1437.         int             ssize, lsize,rsize;
  1438.         ssize = natural_size(node->v.p[0]);
  1439.         rsize = natural_size(node->v.p[1]);
  1440. if (rsize == 0)
  1441. rsize = ssize;
  1442. if (rsize > 4) {
  1443. int fop = op_fmul;
  1444. ap2 = gen_expr(node->v.p[0],F_FREG,rsize);
  1445. ap3 = gen_expr(node->v.p[0],F_MEM,ssize);
  1446. ap1 = gen_expr(node->v.p[1],F_FREG | F_MEM,rsize);
  1447. if (ap1->mode == am_freg)
  1448. gen_code(fop,0,0,0);
  1449. else {
  1450. if (rsize <= 4)
  1451. fop = op_fimul;
  1452. gen_f10code(fop,ssize,ap1,0);
  1453. }
  1454. floatstore(ap3,ssize,flags);
  1455. gen_codef(op_fwait,0,0,0);
  1456. if (!(flags & F_NOVALUE)) {
  1457. ap2 = fstack();
  1458. do_extend(ap2,ssize,size,flags);
  1459. make_legal(ap2,flags,size);
  1460. }
  1461. return ap2;
  1462. }
  1463. if (op == op_imul)
  1464. lsize= -4;
  1465. else
  1466. lsize = 4;
  1467.        ap2 = gen_expr(node->v.p[0],F_ALL | F_NOBIT | F_DEST,ssize);
  1468. mark();
  1469.        ap1 = gen_expr(node->v.p[1],F_ALL,lsize);
  1470. ap3 = xalloc(sizeof(AMODE));
  1471. ap3->mode = ap2->mode;
  1472. ap3->preg = ap2->preg;
  1473. ap3->sreg = ap2->sreg;
  1474. ap3->scale = ap2->scale;
  1475. ap3->offset = ap2->offset;
  1476. if (node->v.p[0]->nodetype == en_bits)
  1477. ap2 = get_bitval(ap2,node->v.p[0],ssize);
  1478. else {
  1479.          make_legal(ap2,F_DREG | F_VOL,4);
  1480. do_extend(ap2,ssize,lsize,F_DREG);
  1481. }
  1482. domul(ap2,ap1,lsize,op);
  1483. freeop(ap1);
  1484. release();
  1485. if (!equal_address(ap2,ap3))
  1486. if (node->v.p[0]->nodetype == en_bits)
  1487. bit_move(ap3,ap2,node->v.p[0],flags,ssize,rsize);
  1488. else
  1489. gen_code(op_mov,ssize,ap3,ap2);
  1490. if (flags & F_NOVALUE)
  1491. freeop(ap2);
  1492. else {
  1493. do_extend(ap2,ssize,size,flags);
  1494.         make_legal(ap2,flags,4);
  1495. }
  1496.         return ap2;
  1497. }
  1499. AMODE    *gen_asmodiv(ENODE *node, int flags, int size, int op, int modflag)
  1500. /*
  1501.  *      generate /= and %= nodes.
  1502.  */
  1503. {       AMODE    *ap1, *ap2,*ap3;
  1504.         int             ssize,lsize,rsize;
  1505.         ssize = natural_size(node->v.p[0]);
  1506.         rsize = natural_size(node->v.p[1]);
  1507. if (rsize == 0)
  1508. rsize = ssize;
  1509. if (rsize > 4) {
  1510. int fop = op_fdiv;
  1511. ap2 = gen_expr(node->v.p[0],F_FREG,rsize);
  1512. ap3 = gen_expr(node->v.p[0],F_MEM,ssize);
  1513. ap1 = gen_expr(node->v.p[1],F_FREG | F_MEM,rsize);
  1514. if (ap1->mode == am_freg)
  1515. gen_code(fop,0,0,0);
  1516. else {
  1517. if (rsize <= 4)
  1518. fop = op_fidiv;
  1519. gen_f10code(fop,ssize,ap1,0);
  1520. }
  1521. floatstore(ap3,ssize,flags);
  1522. gen_codef(op_fwait,0,0,0);
  1523. if (!(flags & F_NOVALUE)) {
  1524. ap2 = fstack();
  1525. do_extend(ap2,ssize,size,flags);
  1526. make_legal(ap2,flags,size);
  1527. }
  1528. return ap2;
  1529. }                                                   
  1530. if (op == op_idiv)                                  
  1531. lsize= -4;                                        
  1532. else                                                
  1533. lsize = 4;                                        
  1534.                                                       
  1535.         ap2 = gen_expr(node->v.p[0],F_ALL | F_NOBIT | F_DEST, ssize);         
  1536. mark();
  1537.         ap1 = gen_expr(node->v.p[1],F_ALL,lsize);         
  1538. ap3 = xalloc(sizeof(AMODE));                      
  1539. ap3->mode = ap2->mode;                            
  1540. ap3->preg = ap2->preg;                            
  1541. ap3->sreg = ap2->sreg;                            
  1542. ap3->scale = ap2->scale;                          
  1543. ap3->offset = ap2->offset;
  1544. if (node->v.p[0]->nodetype == en_bits)
  1545. ap2 = get_bitval(ap2,node->v.p[0],ssize);
  1546. else {
  1547.          make_legal(ap2,F_DREG | F_VOL,4);
  1548. do_extend(ap2,ssize,lsize,F_DREG);
  1549. }
  1550. dodiv(ap2,ap1,ssize,op,modflag);                  
  1551. freeop(ap1);
  1552. release();
  1553. if (!equal_address(ap2,ap3))
  1554. if (node->v.p[0]->nodetype == en_bits)
  1555. bit_move(ap3,ap2,node->v.p[0],flags,ssize,rsize);
  1556. else
  1557. gen_code(op_mov,ssize,ap3,ap2);
  1558. if (flags & F_NOVALUE)                              
  1559. freeop(ap2);                                      
  1560. else {
  1561. do_extend(ap2,ssize,size,flags);
  1562.         make_legal(ap2,flags,4);
  1563. }
  1564.         return ap2;                                       
  1565. }
  1566. AMODE *gen_moveblock(ENODE *node, int flags, int size)      
  1567. {                                                           
  1568. AMODE *ap1, *ap2;                                         
  1569. if (!node->size)                                          
  1570. return(0);
  1571. ap2 = gen_expr(node->v.p[1],F_DREG | F_VOL,4);                     
  1572. mark();
  1573. ap1 = gen_expr(node->v.p[0],F_DREG | F_VOL,4);                     
  1574. gen_push(ESI,am_dreg,0);                                  
  1575. gen_push(EDI,am_dreg,0);                                  
  1576. if (regs[1])                                              
  1577. gen_push(ECX,am_dreg,0);                                
  1578. gen_code(op_mov,4,makedreg(ESI),ap2);                   
  1579. gen_code(op_mov,4,makedreg(EDI),ap1);                     
  1580. gen_code(op_mov,4,makedreg(ECX),make_immed(node->size));  
  1581. gen_code(op_cld,0,0,0);
  1582. gen_code(op_rep,1,0,0);                                   
  1583. gen_code(op_movsb,1,0,0);                               
  1584. if (regs[1])                                              
  1585. gen_pop(ECX,am_dreg,0);
  1586. gen_pop(EDI,am_dreg,0);
  1587. gen_pop(ESI,am_dreg,0);
  1588. freeop(ap2);
  1589. freeop(ap1);
  1590. release();
  1591. return(ap2);
  1592. }
  1593. AMODE    *gen_assign(ENODE *node, int flags, int size)
  1594. /*
  1595.  *      generate code for an assignment node. if the size of the
  1596.  *      assignment destination is larger than the size passed then
  1597.  *      everything below this node will be evaluated with the
  1598.  *      assignment size.
  1599.  */
  1600. {       AMODE    *ap1, *ap2, *ap3,*ap4 = 0;
  1601.         int             ssize,rsize;
  1602. rsize = natural_size(node->v.p[1]);
  1603.         switch( node->v.p[0]->nodetype )
  1604.                 {
  1605. case en_bits:
  1606. ssize = natural_size(node->v.p[0]);
  1607. break;
  1608.                 case en_ub_ref:
  1609. case en_cub:
  1610.                         ssize = 1;
  1611.                         break;
  1612.                 case en_b_ref:
  1613. case en_cb:
  1614.                         ssize = -1;
  1615.                         break;
  1616.                 case en_uw_ref:
  1617. case en_cuw:
  1618.                         ssize = 2;
  1619.                         break;
  1620.                 case en_w_ref:
  1621. case en_cw:
  1622.                         ssize = -2;
  1623.                         break;
  1624.                 case en_l_ref:
  1625. case en_cl:
  1626. ssize = -4;
  1627. break;
  1628.                 case en_ul_ref:
  1629. case en_cul:
  1630. case en_cp:
  1631.                         ssize = 4;
  1632.                         break;
  1633.                 case en_tempref:
  1634.                 case en_regref:
  1635. ssize = node->v.p[0]->v.i >> 8;
  1636. break;
  1637. case en_floatref:
  1638. case en_cf:
  1639. ssize = 6;
  1640. break;
  1641. case en_doubleref:
  1642. case en_cd:
  1643. ssize = 8;
  1644. break;
  1645. case en_longdoubleref:
  1646. case en_cld:
  1647. ssize = 10;
  1648. break;
  1649. default:
  1650. ssize = -4;
  1651.                 }
  1652.         if (chksize( ssize , rsize ))
  1653.                 rsize = ssize;
  1654.         ap2 = gen_expr(node->v.p[1],F_DREG | F_FREG | F_IMMED,rsize);
  1655. mark();
  1656.         ap1 = gen_expr(node->v.p[0],F_ALL | F_NOBIT | F_DEST,ssize);
  1657. if (!equal_address(ap1,ap2) ) {
  1658. if (rsize > 4) {
  1659. floatstore(ap1,ssize,flags);
  1660. gen_codef(op_fwait,0,0,0);
  1661. }
  1662. else {
  1663. if (node->v.p[0]->nodetype == en_bits) {
  1664. bit_move(ap1,ap2,node->v.p[0],flags,ssize,rsize);
  1665. }
  1666. else {
  1667. if (ap2->mode != am_dreg && ap2->mode != am_immed
  1668. && ap1->mode != am_dreg) {
  1669. freeop(ap2);
  1670. ap3 = temp_data();
  1671. gen_code(op_mov,ssize,ap3,ap2);
  1672. gen_code(op_mov,ssize,ap1,ap3);
  1673. }
  1674. else {
  1675.           gen_code(op_mov,ssize,ap1,ap2);
  1676. }
  1677. }
  1678. }
  1679. }
  1680. release();
  1681. if (flags & F_NOVALUE)
  1682. freeop(ap2);
  1683. else {
  1684. do_extend(ap2,ssize,size,flags);
  1685. make_legal(ap2,flags,size);
  1686. }
  1687.         return ap2;
  1688. }
  1689. AMODE    *gen_refassign(ENODE *node, int flags, int size)
  1690. /*
  1691.  *      generate code for an assignment node. if the size of the
  1692.  *      assignment destination is larger than the size passed then
  1693.  *      everything below this node will be evaluated with the
  1694.  *      assignment size.
  1695.  */
  1696. {       AMODE    *ap1, *ap2, *ap3,*ap4;
  1697.         int             ssize,rsize;
  1698. rsize = natural_size(node->v.p[1]);
  1699.         switch( node->v.p[0]->nodetype )
  1700.                 {
  1701. case en_bits:
  1702. ssize = natural_size(node->v.p[0]);
  1703. break;
  1704.                 case en_ub_ref:
  1705. case en_cub:
  1706.                         ssize = 1;
  1707.                         break;
  1708.                 case en_b_ref:
  1709. case en_cb:
  1710.                         ssize = -1;
  1711.                         break;
  1712.                 case en_uw_ref:
  1713. case en_cuw:
  1714.                         ssize = 2;
  1715.                         break;
  1716.                 case en_w_ref:
  1717. case en_cw:
  1718.                         ssize = -2;
  1719.                         break;
  1720.                 case en_l_ref:
  1721. case en_cl:
  1722. ssize = -4;
  1723. break;
  1724.                 case en_ul_ref:
  1725. case en_cul:
  1726. case en_cp:
  1727.                         ssize = 4;
  1728.                         break;
  1729.                 case en_tempref:
  1730.                 case en_regref:
  1731. ssize = node->v.p[0]->v.i >> 8;
  1732. break;
  1733. case en_floatref:
  1734. case en_cf:
  1735. ssize = 6;
  1736. break;
  1737. case en_doubleref:
  1738. case en_cd:
  1739. ssize = 8;
  1740. break;
  1741. case en_longdoubleref:
  1742. case en_cld:
  1743. ssize = 10;
  1744. break;
  1745. default:
  1746. ssize = -4;
  1747.                 }
  1748.         if (chksize( ssize , rsize ))
  1749.                 rsize = ssize;
  1750.         ap2 = gen_expr(node->v.p[1],F_DREG | F_FREG,rsize);
  1751. mark();
  1752.         ap1 = gen_expr(node->v.p[0],F_ALL | F_NOBIT | F_DEST,ssize);
  1753. ap4 = xalloc(sizeof(AMODE));
  1754. ap4->preg = ap1->preg;
  1755. ap4->mode = am_indisp;
  1756. ap4->offset = makenode(en_icon,0,0);
  1757. if (!equal_address(ap1,ap2) )
  1758. if (rsize > 4) {
  1759. floatstore(ap4,ssize,flags);
  1760. gen_codef(op_fwait,0,0,0);
  1761. }
  1762. else
  1763. if (node->v.p[0]->nodetype == en_bits)
  1764. bit_move(ap4,ap2,node->v.p[0],flags,ssize,rsize);
  1765. else
  1766. if (ap2->mode != am_dreg && ap2->mode != am_immed
  1767. && ap4->mode != am_dreg) {
  1768. ap3 = temp_data();
  1769.            gen_code(op_mov,rsize,ap3,ap2);
  1770.            gen_code(op_mov,ssize,ap4,ap3);
  1771. freeop(ap3);
  1772. }
  1773. else
  1774.           gen_code(op_mov,ssize,ap4,ap2);
  1775.         freeop(ap1);
  1776. do_extend(ap2,ssize,size,flags);
  1777. make_legal(ap2,flags,size);
  1778.         return ap2;
  1779. }
  1781. AMODE    *gen_aincdec(ENODE *node, int flags, int size, int op)
  1782. /*
  1783.  *      generate an auto increment or decrement node. op should be
  1784.  *      either op_add (for increment) or op_sub (for decrement).
  1785.  */
  1786. {       AMODE    *ap1,*ap2;
  1787.         int             ssize,rsize;
  1788.         ssize = natural_size(node->v.p[0]);
  1789. if (!(flags & F_NOVALUE)) {
  1790. ap2 = temp_data();
  1791. }
  1792. mark();
  1793.         ap1 = gen_expr(node->v.p[0],F_ALL,ssize);
  1794. if (!(flags &F_NOVALUE)) {
  1795. gen_code(op_mov,ssize,ap2,ap1);
  1796. }
  1797.         gen_code(op,ssize,ap1,make_immed((int)node->v.p[1]));
  1798. freeop(ap1);
  1799. release();
  1800. if (!(flags & F_NOVALUE)) {
  1801. do_extend(ap2,ssize,size,flags);
  1802. make_legal(ap2,flags,size);
  1803. }
  1804.         return ap2;
  1805. }
  1807. int push_param(ENODE *ep, int size)
  1808. /*
  1809.  *      push the operand expression onto the stack.
  1810.  */
  1811. {       AMODE    *ap, *ap2;
  1812. int rv,sz;
  1813. switch (ep->nodetype) {
  1814. case en_absacon:
  1815. ep->v.i = (( SYM *)ep->v.p[0])->value.i;
  1816.                         ap = xalloc(sizeof(AMODE));
  1817.                         ap->mode = am_immed;
  1818.                         ap->offset = ep;     /* use as constant node */
  1819.                         gen_code(op_push,4,ap,0);
  1820. rv = 4;
  1821. break;
  1822.                 case en_napccon:
  1823.                 case en_nacon:
  1824. ep->v.p[0] = ((SYM *)ep->v.p[0])->name;
  1825.                 case en_labcon:
  1826.                 case en_nalabcon:
  1827.                         ap = xalloc(sizeof(AMODE));
  1828.                         ap->mode = am_immed;
  1829.                         ap->offset = ep;     /* use as constant node */
  1830.                         gen_code(op_push,4,ap,0);
  1831.                         make_legal(ap,F_ALL,4);
  1832. rv = 4;
  1833. break;
  1834. case en_cf:
  1835. case en_floatref:
  1836. ap = gen_expr(ep,F_FREG | F_VOL,6);
  1837. gen_code(op_sub,4,makedreg(ESP),make_immed(4));
  1838. ap2 = make_immed(0);
  1839. ap2->preg = ESP;
  1840. ap2->mode = am_indisp;
  1841. gen_codef(op_fstp,6,ap2,0);
  1842. gen_codef(op_fwait,0,0,0);
  1843. rv = 4;
  1844. break;
  1845. case en_cd:
  1846. case en_doubleref:
  1847. ap = gen_expr(ep,F_FREG | F_VOL,8);
  1848. gen_code(op_sub,4,makedreg(ESP),make_immed(8));
  1849. ap2 = make_immed(0);
  1850. ap2->preg = ESP;
  1851. ap2->mode = am_indisp;
  1852. gen_codef(op_fstp,8,ap2,0);
  1853. gen_codef(op_fwait,0,0,0);
  1854. rv = 8;
  1855. break;
  1856. case en_cld:
  1857. case en_longdoubleref:
  1858. ap = gen_expr(ep,F_FREG | F_VOL,8);
  1859. gen_code(op_sub,4,makedreg(ESP),make_immed(10));
  1860. ap2 = make_immed(0);
  1861. ap2->preg = ESP;
  1862. ap2->mode = am_indisp;
  1863. gen_codef(op_fstp,10,ap2,0);
  1864. gen_codef(op_fwait,0,0,0);
  1865. rv = 8;
  1866. break;
  1867. case en_rcon: 
  1868. case en_fcon:
  1869. case en_lrcon:
  1870. rv = size;
  1871. if (rv == 6) rv= 4;
  1872. if (rv == 10) rv= 12;
  1873. ap = gen_expr(ep,F_FREG | F_VOL,size);
  1874. make_floatconst(ap,size);
  1875. gen_code(op_sub,4,makedreg(ESP),make_immed(rv));
  1876. ap2 = make_immed(0);
  1877. ap2->preg = ESP;
  1878. ap2->mode = am_indisp;
  1879. gen_codef(op_fstp,rv,ap2,0);
  1880. gen_codef(op_fwait,0,0,0);
  1881. break;
  1882. default:
  1883. rv = 4;
  1884.           ap = gen_expr(ep,F_ALL,4);
  1885. if (ap->mode != am_dreg &&ap->mode != am_immed&& ap->mode != am_freg) {
  1886. sz = natural_size(ep->v.p[0]);
  1887. if (sz < 4 && sz >-4) 
  1888. do_extend(ap,sz,4,F_DREG);
  1889. }
  1890. if (ap->mode == am_freg) {
  1891. gen_code(op_push,4,makedreg(3),0);
  1892. ap2 = make_immed(0);
  1893. ap2->preg = ESP;
  1894. ap2->mode = am_indisp;
  1895. gen_codef(op_fistp,4,ap2,0);
  1896. gen_codef(op_fwait,0,0,0);
  1897. }
  1898. else
  1899. gen_code(op_push,4,ap,0);
  1900. break;
  1901. }
  1902.         freeop(ap);
  1903. stackdepth += rv;
  1904. return(rv);
  1905. }
  1906. int push_stackblock(ENODE *ep)
  1907. {
  1908. AMODE *ap;
  1909. int sz = (ep->size + stackadd) &stackmod;
  1910. if (!sz)
  1911. return(0);
  1912. gen_code(op_sub,4,makedreg(ESP),make_immed(sz));
  1913. gen_code(op_push,4,makedreg(ESI),0);
  1914. gen_code(op_push,4,makedreg(EDI),0);
  1915. stackdepth+=sz+8;
  1916. gen_code(op_lea,4,makedreg(EDI),make_stack(-8));
  1917. switch (ep->nodetype) {
  1918.                 case en_napccon:
  1919.                 case en_nacon:
  1920. ep->v.p[0] = ((SYM *)ep->v.p[0])->name;
  1921.                 case en_nalabcon:
  1922.                 case en_labcon:
  1923.                         ap = xalloc(sizeof(AMODE));
  1924.                         ap->mode = am_direct;
  1925.                         ap->offset = ep;     /* use as constant node */
  1926.                         gen_code(op_lea,4,makedreg(ESI),ap);
  1927. break;
  1928. case en_absacon:
  1929. ep->v.i = (( SYM *)ep->v.p[0])->value.i;
  1930.                         ap = xalloc(sizeof(AMODE));
  1931.                         ap->mode = am_direct;
  1932.                         ap->offset = ep;     /* use as constant node */
  1933.                         gen_code(op_lea,4,makedreg(ESI),ap);
  1934. break;
  1935. default:
  1936.           ap = gen_expr(ep,F_DREG | F_MEM | F_IMMED,4);
  1937. gen_code(op_mov,4,makedreg(ESI),ap);
  1938. break;
  1939. }
  1940. gen_code(op_mov,4,makedreg(ECX),make_immed(sz));
  1941. gen_code(op_cld,0,0,0);
  1942. gen_code(op_rep,0,0,0);
  1943. gen_code(op_movsb,0,0,0);
  1944. gen_code(op_pop,4,makedreg(EDI),0);
  1945. gen_code(op_pop,4,makedreg(ESI),0);
  1946. stackdepth-=8;
  1947. freeop(ap);
  1948. return(sz);
  1949. }
  1951. int     gen_parms(ENODE *plist,int size)
  1952. /*
  1953.  *      push a list of parameters onto the stack and return the
  1954.  *      size of parameters pushed.
  1955.  */
  1956. {       int     i;
  1957.         i = 0;
  1958.         while( plist != 0 )
  1959.                 {         
  1960. if (plist->nodetype == en_stackblock)
  1961. i+=push_stackblock(plist->v.p[0]);
  1962. else
  1963.                  i+=push_param(plist->v.p[0],size);
  1964.                 plist = plist->v.p[1];
  1965.                 }
  1966.         return i;
  1967. }
  1969. AMODE    *gen_fcall(ENODE *node,int flags, int size)
  1970. /*
  1971.  *      generate a function call node and return the address mode
  1972.  *      of the result.
  1973.  */
  1974. {       AMODE    *ap, *result;
  1975. ENODE *node2;
  1976.         int             i,ssize;
  1977.         result = temp_data();
  1978.         temp_data(); temp_data();       /* push any used data registers */
  1979.         freeop(result); freeop(result); freeop(result);
  1980. if (node->nodetype == en_callblock) {
  1981. i = gen_parms(node->v.p[1]->v.p[1]->v.p[1]->v.p[0],size);
  1982.        ap = gen_expr(node->v.p[0],F_ALL,4);
  1983. gen_code(op_push,4,ap,0);
  1984. i+=4;
  1985. stackdepth+=4;
  1986. node = node->v.p[1];
  1987. freeop(ap);
  1988. ssize = 4;
  1989. }
  1990. else {
  1991.         i = gen_parms(node->v.p[1]->v.p[1]->v.p[0],size);    /* generate parameters */
  1992. ssize = node->v.p[0]->v.i;
  1993. }
  1994. if (node->nodetype == en_intcall) {
  1995. AMODE *ap2 = xalloc(sizeof(AMODE));
  1996. ap2->mode = am_seg;
  1997. ap2->seg = e_cs;
  1998. gen_code(op_pushfd,0,0,0);
  1999. gen_code(op_push,0,ap2,0);
  2000. }
  2002.         if( node->v.p[1]->v.p[0]->nodetype == en_nacon || node->v.p[1]->v.p[0]->nodetype == en_napccon ) {
  2003. SYM *sp= node->v.p[1]->v.p[0]->v.p[0];
  2004. if (sp->inreg) {
  2005. ap = makedreg(sp->value.i);
  2006. }
  2007. else {
  2008. node->v.p[1]->v.p[0]->v.p[0] = sp->name;
  2009.                  ap = make_offset(node->v.p[1]->v.p[0]);
  2010. ap->mode = am_immed;
  2011. }
  2012.                 gen_code(op_call,0,ap,0);
  2013. }
  2014.         else
  2015.                 {
  2016. if (node->v.p[1]->v.p[0]->nodetype == en_l_ref) {
  2017. node2=node->v.p[1]->v.p[0]->v.p[0];
  2018. }
  2019. else {
  2020. if (node->v.p[1]->v.p[0]->nodetype != en_tempref)
  2021. DIAG("gen_fcall - questionable indirection");
  2022. node2=node->v.p[1]->v.p[0];
  2023. }
  2024.                 ap = gen_expr(node2,F_ALL,4);
  2025.                 freeop(ap);
  2026.                 gen_code(op_call,4,ap,0);
  2027.                 }
  2028.         if( i != 0 ) {
  2029. if (i == 4)
  2030. gen_code(op_pop,4,makedreg(ECX),0);
  2031. else
  2032.                  gen_code(op_add,4,makedreg(4),make_immed(i));
  2033. stackdepth -= i;
  2034. }
  2035. if (ssize > 4) {
  2036. result = fstack();
  2037. }
  2038. else {
  2039.           result = temp_data();
  2040.          if( result->preg != EAX)
  2041.                 gen_code(op_mov,4,result,makedreg(EAX));
  2042. }
  2043. result->tempflag = 1;
  2044. do_extend(result,ssize,size,flags);
  2045. make_legal(result,flags,size);
  2046.         return result;
  2047. }
  2048. AMODE    *gen_pfcall(ENODE *node,int flags, int size)
  2049. /*
  2050.  *      generate a function call node to a pascal function
  2051.  * and return the address mode of the result.
  2052.  */
  2053. {       AMODE    *ap, *result;
  2054.         int             i,ssize;
  2055. ENODE * invnode = 0,*anode,*node2;
  2057. /* invert the parameter list */
  2058. if (node->nodetype == en_pcallblock)
  2059. anode = node->v.p[1]->v.p[1]->v.p[1]->v.p[0];
  2060. else
  2061. anode = node->v.p[1]->v.p[1]->v.p[0];
  2062. while (anode) {
  2063. invnode = makenode(anode->nodetype,anode->v.p[0],invnode);
  2064. anode = anode->v.p[1];
  2065. }
  2066.         result = temp_data();
  2067.         temp_data(); temp_data();       /* push any used data registers */
  2068.         freeop(result); freeop(result); freeop(result);
  2069. if (node->nodetype == en_pcallblock) {
  2070.        ap = gen_expr(node->v.p[0],F_ALL,4);
  2071. gen_code(op_push,4,ap,0);
  2072. freeop(ap);
  2073. i=4;
  2074. stackdepth+=4;
  2075. i += gen_parms(invnode,size);
  2076. node = node->v.p[1];
  2077. ssize = 4;
  2078. }
  2079. else {
  2080.         i = gen_parms(invnode,size);    /* generate parameters */
  2081. ssize = node->v.p[0]->v.i;
  2082. }
  2084.         if( node->v.p[1]->v.p[0]->nodetype == en_nacon || node->v.p[1]->v.p[0]->nodetype == en_napccon ) {
  2085. SYM *sp= node->v.p[1]->v.p[0]->v.p[0];
  2086. if (sp->inreg) {
  2087. ap = makedreg(sp->value.i);
  2088. }
  2089. else {
  2090. node->v.p[0]->v.p[0]->v.p[0] = sp->name;
  2091.                  ap = make_offset(node->v.p[1]->v.p[0]);
  2092. ap->mode = am_immed;
  2093. }
  2094.                 gen_code(op_call,0,ap,0);
  2095. }
  2096.         else
  2097.                 {
  2098. if (node->v.p[1]->v.p[0]->nodetype == en_l_ref) {
  2099. node2=node->v.p[1]->v.p[0]->v.p[0];
  2100. }
  2101. else {
  2102. if (node->v.p[1]->v.p[0]->nodetype != en_tempref)
  2103. DIAG("gen_fcall - questionable indirection");
  2104. node2=node->v.p[1]->v.p[0];
  2105. }
  2106.                 ap = gen_expr(node2,F_ALL,4);
  2107.                 freeop(ap);
  2108.                 gen_code(op_call,4,ap,0);
  2109.                 }
  2110. stackdepth -= i;
  2111. if (ssize > 4) {
  2112. result = fstack();
  2113. }
  2114. else {
  2115.           result = temp_data();
  2116.          if( result->preg != EAX)
  2117.                 gen_code(op_mov,4,result,makedreg(EAX));
  2118. }
  2119. result->tempflag = 1;
  2120. do_extend(result,ssize,size,flags);
  2121. make_legal(result,flags,size);
  2122.         return result;
  2123. }
  2125. AMODE    *gen_expr(ENODE *node, int flags, int size)
  2126. /*
  2127.  *      general expression evaluation. returns the addressing mode
  2128.  *      of the result.
  2129.  */
  2130. {
  2131. AMODE    *ap1, *ap2;
  2132.         int             lab0, lab1;
  2133.         int             natsize;
  2134.         if( node == 0 )
  2135.                 {
  2136.                 DIAG("null node in gen_expr.");
  2137.                 return 0;
  2138.                 }
  2139.         switch( node->nodetype )
  2140.                 {
  2141. case en_bits:
  2142. size = natural_size(node->v.p[0]);
  2143. ap1 = gen_expr(node->v.p[0],F_ALL,size);
  2144. if (!(flags & F_NOBIT))
  2145. bit_legal(ap1,node,size);
  2146. return ap1;
  2147. case en_cb: 
  2148. case en_cub:
  2149. case en_cw: 
  2150. case en_cuw:
  2151. case en_cl: 
  2152. case en_cul:
  2153. case en_cf: 
  2154. case en_cd: 
  2155. case en_cld: 
  2156. case en_cp:
  2157. ap1 = gen_expr(node->v.p[0],flags | F_MEM | F_DREG | F_FREG,natural_size(node->v.p[0]));
  2158.                  do_extend(ap1,natural_size(node->v.p[0]),size,flags);
  2159. make_legal(ap1,flags,size);
  2160. return ap1;
  2161.                 case en_napccon:
  2162.                 case en_nacon:
  2163. node->v.p[0] = ((SYM *)node->v.p[0])->name;
  2164.                 case en_nalabcon:
  2165.                 case en_labcon:
  2166.                         ap1 = temp_data();
  2167. ap1->tempflag = TRUE;
  2168.                         ap2 = xalloc(sizeof(AMODE));
  2169.                         ap2->mode = am_direct;
  2170.                         ap2->offset = node;     /* use as constant node */
  2171.                         gen_code(op_lea,4,ap1,ap2);
  2172.                         make_legal(ap1,flags,size);
  2173.                         return ap1;             /* return reg */
  2174.                 case en_icon:
  2175. case en_lcon: case en_lucon: case en_iucon: case en_ccon:
  2176. case en_rcon: case en_lrcon: case en_fcon:
  2177.                         ap1 = xalloc(sizeof(AMODE));
  2178.                         ap1->mode = am_immed;
  2179.                         ap1->offset = node;
  2180.                         make_legal(ap1,flags,size);
  2181.                         return ap1;
  2182. case en_absacon:
  2183. node->v.i = ((SYM *)node->v.p[0])->value.i;
  2184.                         ap1 = temp_data();
  2185. ap1->tempflag = TRUE;
  2186.                         ap2 = xalloc(sizeof(AMODE));
  2187.                         ap2->mode = am_direct;
  2188.                         ap2->offset = node;     /* use as constant node */
  2189.                         gen_code(op_lea,4,ap1,ap2);
  2190.                         make_legal(ap1,flags,size);
  2191.                         return ap1;             /* return reg */
  2192.                 case en_autocon:
  2193.                 case en_autoreg:
  2194.                         ap1 = temp_data();
  2195. ap1->tempflag = TRUE;
  2196.                         ap2 = xalloc(sizeof(AMODE));
  2197.                 ap2->mode = am_indisp;
  2198. ap2->preg = ESP;
  2199. if (prm_linkreg) {
  2200.             ap2->preg = EBP;
  2201.             ap2->offset = makenode(en_icon,(char *)((SYM *)node->v.p[0])->value.i,0);
  2202. }
  2203. else if (((SYM *)node->v.p[0])->funcparm)
  2204.                  ap2->offset = makenode(en_icon,(char *)(((SYM *)node->v.p[0])->value.i+framedepth+stackdepth),0);
  2205.                  else
  2206. ap2->offset = makenode(en_icon,(char *)(((SYM *)node->v.p[0])->value.i+stackdepth+lc_maxauto),0);
  2207.                         gen_code(op_lea,4,ap1,ap2);
  2208.                         make_legal(ap1,flags,size);
  2209.                         return ap1;             /* return reg */
  2210.                 case en_b_ref:
  2211.                 case en_w_ref:
  2212.                 case en_ub_ref:
  2213.                 case en_uw_ref:
  2214.                 case en_l_ref:
  2215.                 case en_ul_ref:
  2216. case en_floatref:
  2217. case en_doubleref:
  2218. case en_longdoubleref:
  2219.                         return gen_deref(node,flags,size);
  2220.                 case en_tempref:
  2221.                 case en_regref:
  2222.                         ap1 = xalloc(sizeof(AMODE));
  2223. ap1->tempflag = 0;
  2224.                         if( (node->v.i & 0xff) < 16 )
  2225.                                 {
  2226.                                 ap1->mode = am_dreg;
  2227.                                 ap1->preg = node->v.i & 0xff;
  2228. ap1->tempflag = 1;
  2229.                                 }
  2230.                         else
  2231. if ((node->v.i &0xff) < 32)
  2232.                                 {
  2233.                                 ap1->mode = am_dreg;
  2234.                                 ap1->preg = (node->v.i & 0xff)- 12;
  2235.                                 }
  2236. else
  2237.                                 {
  2238.                                 ap1->mode = am_freg;
  2239.                                 ap1->preg = (node->v.i & 0xff) - 32;
  2240.                                 }
  2241.                         ap1->tempflag = 0;      /* not a temporary */
  2242.                  do_extend(ap1,node->v.i >> 8,size,flags);
  2243.                         make_legal(ap1,flags,size);
  2244.                         return ap1;
  2245.                 case en_uminus:
  2246.                         return gen_unary(node,flags,size,op_neg, op_fchs);
  2247.                 case en_compl:
  2248.                         return gen_unary(node,flags,size,op_not, op_not);
  2249.                 case en_add:
  2250.                         return gen_binary(node,flags,size,op_add,op_fadd);
  2251.                 case en_sub:
  2252.                         return gen_binary(node,flags,size,op_sub,op_fsub);
  2253.                 case en_and:
  2254.                         return gen_binary(node,flags,size,op_and,op_and);
  2255.                 case en_or:
  2256.                         return gen_binary(node,flags,size,op_or,op_or);
  2257. case en_xor:
  2258. return gen_xbin(node,flags,size,op_xor,op_xor);
  2259. case en_pmul:
  2260. return gen_pmul(node,flags,size);
  2261. case en_pdiv:
  2262. return gen_pdiv(node,flags,size);
  2263.                 case en_mul:
  2264.                         return gen_mul(node,flags,size,op_imul);
  2265.                 case en_umul:
  2266.                         return gen_mul(node,flags,size,op_mul);
  2267.                 case en_div:
  2268.                         return gen_modiv(node,flags,size,op_idiv,0);
  2269.                 case en_udiv:
  2270.                         return gen_modiv(node,flags,size,op_div,0);
  2271.                 case en_mod:
  2272.                         return gen_modiv(node,flags,size,op_idiv,1);
  2273.                 case en_umod:
  2274.                         return gen_modiv(node,flags,size,op_div,1);
  2275.                 case en_alsh:
  2276.                         return gen_shift(node,flags,size,op_sal);
  2277.                 case en_arsh:
  2278.                         return gen_shift(node,flags,size,op_sar);
  2279.                 case en_lsh:
  2280.                         return gen_shift(node,flags,size,op_shl);
  2281.                 case en_rsh:
  2282.                         return gen_shift(node,flags,size,op_shr);
  2283.                 case en_asadd:
  2284.                         return gen_asadd(node,flags,size,op_add,op_fadd);
  2285.                 case en_assub:
  2286.                         return gen_asadd(node,flags,size,op_sub,op_fsub);
  2287.                 case en_asand:
  2288.                         return gen_aslogic(node,flags,size,op_and);
  2289.                 case en_asor:
  2290.                         return gen_aslogic(node,flags,size,op_or);
  2291.                 case en_asxor:
  2292.                         return gen_aslogic(node,flags,size,op_xor);
  2293.                 case en_aslsh:
  2294.                         return gen_asshift(node,flags,size,op_shl);
  2295.                 case en_asrsh:
  2296.                         return gen_asshift(node,flags,size,op_shr);
  2297.                 case en_asalsh:
  2298.                         return gen_asshift(node,flags,size,op_sal);
  2299.                 case en_asarsh:
  2300.                         return gen_asshift(node,flags,size,op_sar);
  2301.                 case en_asmul:
  2302.                         return gen_asmul(node,flags,size, op_imul);
  2303.                 case en_asumul:
  2304.                         return gen_asmul(node,flags,size,op_mul);
  2305.                 case en_asdiv:
  2306.                         return gen_asmodiv(node,flags,size,op_idiv,FALSE);
  2307.                 case en_asudiv:
  2308.                         return gen_asmodiv(node,flags,size,op_div,FALSE);
  2309.                 case en_asmod:
  2310.                         return gen_asmodiv(node,flags,size,op_idiv,TRUE);
  2311.                 case en_asumod:
  2312.                         return gen_asmodiv(node,flags,size,op_div,TRUE);
  2313.                 case en_assign:
  2314.                         return gen_assign(node,flags,size);
  2315.                 case en_refassign:
  2316.                         return gen_refassign(node,flags|F_NOVALUE,size);
  2317.                 case en_moveblock:
  2318.                         return gen_moveblock(node,flags,size);
  2319.                 case en_ainc:
  2320.                         return gen_aincdec(node,flags,size,op_add);
  2321.                 case en_adec:
  2322.                         return gen_aincdec(node,flags,size,op_sub);
  2323.                 case en_land:   case en_lor:
  2324.                 case en_eq:     case en_ne:
  2325.                 case en_lt:     case en_le:
  2326.                 case en_gt:     case en_ge:
  2327.                 case en_ult:    case en_ule:
  2328.                 case en_ugt:    case en_uge:
  2329.                 case en_not:
  2330.                         lab0 = nextlabel++;
  2331.                         lab1 = nextlabel++;
  2332.                         falsejp(node,lab0);
  2333.                         ap1 = temp_data();
  2334.                         gen_code(op_sub,4,ap1,ap1);
  2335.                         gen_code(op_inc,4,ap1,0);
  2336.                         gen_code(op_jmp,0,make_label(lab1),0);
  2337.                         gen_label(lab0);
  2338.                         gen_code(op_sub,4,ap1,ap1);
  2339.                         gen_label(lab1);
  2340.                         return ap1;
  2341.                 case en_cond:
  2342.                         return gen_hook(node,flags,size);
  2343.                 case en_void:
  2344.                         natsize = natural_size(node->v.p[0]);
  2345.                         freeop(gen_expr(node->v.p[0],F_ALL | F_NOVALUE,natsize));
  2346.                         return gen_expr(node->v.p[1],flags,size);
  2347. case en_pfcall: case en_pfcallb:  case en_pcallblock:
  2348. return gen_pfcall(node,flags,size);
  2349.                 case en_fcall:  case en_callblock: case en_fcallb:
  2350.                 case en_trapcall:
  2351. case en_intcall:
  2352.                         return gen_fcall(node,flags,size);
  2353.                 default:
  2354.                         DIAG("uncoded node in gen_expr.");
  2355.                         return 0;
  2356.                 }
  2357. }
  2359. int     natural_size(ENODE *node)
  2360. /*
  2361.  *      return the natural evaluation size of a node.
  2362.  */
  2363. {       int     siz0, ssize;
  2364.         if( node == 0 )
  2365.                 return 0;
  2366.         switch( node->nodetype )
  2367.                 {
  2368. case en_absacon:
  2369. return stdaddrsize;
  2370. case en_bits:
  2371. return 4;
  2372.                 case en_icon:
  2373. case en_lcon: 
  2374. case en_lucon: 
  2375. case en_iucon: 
  2376. return 0;
  2377. case en_ccon:                 
  2378. return 0;
  2379. case en_rcon:
  2380. return 0;
  2381. case en_doubleref:
  2382. return 8;
  2383. case en_lrcon:
  2384. return 0;
  2385. case en_longdoubleref:
  2386. return 10;
  2387. case en_fcon:
  2388. return 0;
  2389. case en_floatref:
  2390. return 6;
  2391. case en_trapcall:
  2392.                 case en_labcon:
  2393.                 case en_nacon:  case en_autocon:  case en_autoreg:
  2394.                 case en_napccon: case en_nalabcon:
  2395. return stdaddrsize;
  2396. case en_l_ref:
  2397. case en_cl:
  2398. return -4;
  2399. case en_pfcall: case en_pfcallb: 
  2400. case en_fcall: case en_intcall: case en_callblock: case en_fcallb:
  2401. case en_pcallblock:
  2402. return natural_size(node->v.p[1]);
  2403. case en_tempref:
  2404. case en_regref:
  2405. return node->v.i >> 8;
  2406.                 case en_ul_ref:
  2407. case en_cul:
  2408.                         return 4;
  2409. case en_cp:
  2410. return stdaddrsize;
  2411.                 case en_ub_ref:
  2412. case en_cub:
  2413. return 1;
  2414.                 case en_b_ref:
  2415. case en_cb:
  2416.                         return -1;
  2417.                 case en_uw_ref:
  2418. case en_cuw:
  2419. return 2;
  2420.                 case en_cw:
  2421.                 case en_w_ref:
  2422.                         return -2;
  2423. case en_cd:
  2424. return 8;
  2425. case en_cld:
  2426. return stdldoublesize;
  2427. case en_cf:
  2428. return 6;
  2429.                 case en_not:    case en_compl:
  2430.                 case en_uminus: case en_assign: case en_refassign:
  2431.                 case en_ainc:   case en_adec:
  2432. case en_moveblock: case en_stackblock:
  2433.                         return natural_size(node->v.p[0]);
  2434.                 case en_add:    case en_sub:
  2435. case en_umul: case en_udiv: case en_umod: case en_pmul:
  2436.                 case en_mul:    case en_div:  case en_pdiv:
  2437.                 case en_mod:    case en_and:
  2438.                 case en_or:     case en_xor:
  2439. case en_asalsh: case en_asarsh: case en_alsh: case en_arsh:
  2440.                 case en_lsh:    case en_rsh:
  2441.                 case en_eq:     case en_ne:
  2442.                 case en_lt:     case en_le:
  2443.                 case en_gt:     case en_ge:
  2444. case en_ugt: case en_uge: case en_ult: case en_ule:
  2445.                 case en_land:   case en_lor:
  2446.                 case en_asadd:  case en_assub:
  2447.                 case en_asmul:  case en_asdiv:
  2448.                 case en_asmod:  case en_asand:
  2449. case en_asumod: case en_asudiv: case en_asumul:
  2450.                 case en_asor:   case en_aslsh:  case en_asxor:
  2451.                 case en_asrsh:
  2452.                         siz0 = natural_size(node->v.p[0]);
  2453.                         ssize = natural_size(node->v.p[1]);
  2454.                         if( chksize(ssize, siz0 ))
  2455.                                 return ssize;
  2456.                         else
  2457.                                 return siz0;
  2458.                 case en_void:   case en_cond:
  2459.                         return natural_size(node->v.p[1]);
  2460.                 default:
  2461.                         DIAG("natural size error.");
  2462.                         break;
  2463.                 }
  2464.         return 0;
  2465. }
  2467. void gen_compare(ENODE *node, int btype1, int btype2, int btype3, int btype4, int label)
  2468. /*
  2469.  *      generate code to do a comparison of the two operands of
  2470.  *      node.
  2471.  */
  2472. {       AMODE    *ap1, *ap2,  *ap3;
  2473.         int             size;
  2474. int btype = btype1;
  2475. ap3 = 0;
  2476.         size = natural_size(node);
  2477. if (size > 4) {
  2478. ap1 = gen_expr(node->v.p[0],F_FREG | F_VOL, size);
  2479. ap2 = gen_expr(node->v.p[1],F_ALL, size);
  2480. if (ap2->mode == am_freg) {
  2481. gen_codef(op_fcompp,0,0,0);
  2482. }
  2483. else
  2484. gen_codef(op_fcomp,size,ap2,0);
  2485. if (regs[0])
  2486. gen_push(EAX,am_dreg,0);
  2487. gen_codef(op_fstsw,2,makedreg(EAX),0);
  2488. gen_codef(op_fwait,0,0,0);
  2489. gen_code(op_sahf,0,0,0);
  2490. if (regs[0])
  2491. gen_pop(EAX,am_dreg,0);
  2492. gen_branch(btype3,0,make_label(label));
  2493. return;
  2495. }
  2496.         ap1 = gen_expr(node->v.p[0],F_ALL,size);
  2497. mark();
  2498.         ap2 = gen_expr(node->v.p[1],F_ALL,size);
  2499. if (ap1->mode != am_dreg) {
  2500. if (ap2->mode == am_immed)  {
  2501. if (ap1->mode == am_immed)
  2502. goto cmp2;
  2503. }
  2504. else {
  2505. if (ap2->mode == am_dreg) {
  2506. swapit:
  2507. ap3 = ap2;
  2508. ap2 = ap1;
  2509. ap1 = ap3;
  2510. ap3 = 0;
  2511. btype = btype2;
  2512. }
  2513. else  
  2514. if (ap1->mode == am_immed) {
  2515. goto swapit;
  2516. }
  2517. else {
  2518. cmp2:
  2519. ap3 = ap1;
  2520.                ap1 = temp_data();
  2521. gen_code(op_mov,size,ap1,ap3);
  2522.                make_legal(ap1,F_DREG,size);
  2523. }
  2524. }
  2525. }
  2526. if (ap1->mode == am_dreg && ap2->mode == am_immed && ap2->offset->v.i == 0)
  2527.          gen_code(op_or,size,ap1,ap1);
  2528.         else
  2529. gen_code(op_cmp,size,ap1,ap2);
  2530. release();
  2531.         gen_branch(btype,0,make_label(label));
  2532. if (ap3) {
  2533. freeop(ap1);
  2534. freeop(ap2);
  2535. freeop(ap3);
  2536. }
  2537. else {
  2538.          freeop(ap2);
  2539.          freeop(ap1);
  2540. }
  2541. }
  2543. void truejp(ENODE *node, int label)
  2544. /*
  2545.  *      generate a jump to label if the node passed evaluates to
  2546.  *      a true condition.
  2547.  */
  2548. {       AMODE    *ap1;
  2549.         int             ssize;
  2550.         int             lab0;
  2551.         if( node == 0 )
  2552.                 return;
  2553.         switch( node->nodetype )
  2554.                 {
  2555.                 case en_eq:
  2556.                         gen_compare(node,op_je,op_je,op_je,op_je,label);
  2557.                         break;
  2558.                 case en_ne:
  2559.                         gen_compare(node,op_jne,op_jne,op_jne,op_jne,label);
  2560.                         break;
  2561.                 case en_lt:
  2562.                         gen_compare(node,op_jl,op_jg,op_jb,op_ja,label);
  2563.                         break;
  2564.                 case en_le:
  2565.                         gen_compare(node,op_jle,op_jge,op_jbe,op_jnc,label);
  2566.                         break;
  2567.                 case en_gt:
  2568.                         gen_compare(node,op_jg,op_jl,op_ja,op_jb,label);
  2569.                         break;
  2570.                 case en_ge:
  2571.                         gen_compare(node,op_jge,op_jle,op_jnc,op_jbe,label);
  2572.                         break;
  2573.                 case en_ult:
  2574.                         gen_compare(node,op_jb,op_ja,op_jb,op_ja,label);
  2575.                         break;
  2576.                 case en_ule:
  2577.                         gen_compare(node,op_jbe,op_jnc,op_jbe,op_jnc,label);
  2578.                         break;
  2579.                 case en_ugt:
  2580.                         gen_compare(node,op_ja,op_jb,op_ja,op_jb,label);
  2581.                         break;
  2582.                 case en_uge:
  2583.                         gen_compare(node,op_jnc,op_jbe,op_jnc,op_jbe,label);
  2584.                         break;
  2585.                 case en_land:
  2586.                         lab0 = nextlabel++;
  2587.                         falsejp(node->v.p[0],lab0);
  2588.                         truejp(node->v.p[1],label);
  2589.                         gen_label(lab0);
  2590.                         break;
  2591.                 case en_lor:
  2592.                         truejp(node->v.p[0],label);
  2593.                         truejp(node->v.p[1],label);
  2594.                         break;
  2595.                 case en_not:
  2596.                         falsejp(node->v.p[0],label);
  2597.                         break;
  2598.                 default:
  2599.                         ssize = natural_size(node);    
  2600. if (isintconst(node->nodetype)) {
  2601. if (node->v.i != 0) 
  2602.                          gen_code(op_jmp,0,make_label(label),0);
  2603. break;
  2604. }
  2605. else
  2606. if (ssize > 4) {
  2607. ap1 = gen_expr(node,F_FREG | F_VOL, ssize);
  2608. }
  2609. else
  2610.                          ap1 = gen_expr(node,F_ALL,ssize);
  2611. if (ssize > 4) {
  2612. gen_codef(op_fldz,0,0,0);
  2613. gen_codef(op_fcompp,0,0,0);
  2614. if (regs[0])
  2615. gen_push(EAX,am_dreg,0);
  2616. gen_codef(op_fstsw,2,makedreg(EAX),0);
  2617. gen_codef(op_fwait,0,0,0);
  2618. gen_code(op_sahf,0,0,0);
  2619. if (regs[0])
  2620. gen_pop(EAX,am_dreg,0);
  2621. }
  2622. else {
  2623. if (ap1->mode == am_dreg) 
  2624.                          gen_code(op_or,ssize,ap1,ap1);
  2625. else
  2626.                          gen_code(op_test,ssize,ap1,make_immedt(0xffffffffL,ssize));
  2627.                          freeop(ap1);
  2628. }
  2629.                         gen_branch(op_jne,0,make_label(label));
  2630.                         break;
  2631.                 }
  2632. }
  2634. void falsejp(ENODE *node, int label)
  2635. /*
  2636.  *      generate code to execute a jump to label if the expression
  2637.  *      passed is false.
  2638.  */
  2639. {       AMODE    *ap1;
  2640.         int             ssize;
  2641.         int             lab0;
  2642.         if( node == 0 )
  2643.                 return;
  2644.         switch( node->nodetype )
  2645.                 {
  2646.                 case en_eq:
  2647.                         gen_compare(node,op_jne,op_jne,op_jne,op_jne,label);
  2648.                         break;
  2649.                 case en_ne:
  2650.                         gen_compare(node,op_je,op_je,op_je,op_je,label);
  2651.                         break;
  2652.                 case en_lt:
  2653.                         gen_compare(node,op_jge,op_jle,op_jnc,op_jbe,label);
  2654.                         break;
  2655.                 case en_le:
  2656.                         gen_compare(node,op_jg,op_jl,op_ja,op_jb,label);
  2657.                         break;
  2658.                 case en_gt:
  2659.                         gen_compare(node,op_jle,op_jge,op_jbe,op_jnc,label);
  2660.                         break;
  2661.                 case en_ge:
  2662.                         gen_compare(node,op_jl,op_jg,op_jb,op_ja,label);
  2663.                         break;
  2664.                 case en_ult:
  2665.                         gen_compare(node,op_jnc,op_jbe,op_jnc,op_jbe,label);
  2666.                         break;
  2667.                 case en_ule:
  2668.                         gen_compare(node,op_ja,op_jb,op_ja,op_jb,label);
  2669.                         break;
  2670.                 case en_ugt:
  2671.                         gen_compare(node,op_jbe,op_jnc,op_jbe,op_jnc,label);
  2672.                         break;
  2673.                 case en_uge:
  2674.                         gen_compare(node,op_jb,op_ja,op_jb,op_ja,label);
  2675.                         break;
  2676.                 case en_land:
  2677.                         falsejp(node->v.p[0],label);
  2678.                         falsejp(node->v.p[1],label);
  2679.                         break;
  2680.                 case en_lor:
  2681.                         lab0 = nextlabel++;
  2682.                         truejp(node->v.p[0],lab0);
  2683.                         falsejp(node->v.p[1],label);
  2684.                         gen_label(lab0);
  2685.                         break;
  2686.                 case en_not:
  2687.                         truejp(node->v.p[0],label);
  2688.                         break;
  2689.                 default:
  2690.                         ssize = natural_size(node);    
  2691. if (isintconst(node->nodetype)) {
  2692. if (node->v.i == 0) 
  2693.                          gen_code(op_jmp,0,make_label(label),0);
  2694. break;
  2695. }
  2696. else
  2697. if (ssize > 4) {
  2698. ap1 = gen_expr(node,F_FREG | F_VOL, ssize);
  2699. }
  2700. else
  2701.                          ap1 = gen_expr(node,F_ALL,ssize);
  2702. if (ssize > 4) {
  2703. gen_codef(op_fldz,0,0,0);
  2704. gen_codef(op_fcompp,0,0,0);
  2705. if (regs[0])
  2706. gen_push(EAX,am_dreg,0);
  2707. gen_codef(op_fstsw,2,makedreg(EAX),0);
  2708. gen_codef(op_fwait,0,0,0);
  2709. gen_code(op_sahf,0,0,0);
  2710. if (regs[0])
  2711. gen_pop(EAX,am_dreg,0);
  2712. }
  2713. else {
  2714. if (ap1->mode == am_dreg) 
  2715.                          gen_code(op_or,ssize,ap1,ap1);
  2716. else
  2717.                          gen_code(op_test,ssize,ap1,make_immedt(0xffffffffL,ssize));
  2718.                          freeop(ap1);
  2719. }
  2720.                         gen_branch(op_je,0,make_label(label));
  2721.                         break;
  2722.                 }
  2723. }