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

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

编译器/解释器

开发平台：

Others

GSTMT68.C：源码内容
  1. /*
  2.  * 68K/386 32-bit C compiler.
  3.  *
  4.  * copyright (c) 1997, David Lindauer
  5.  * 
  6.  * This compiler is intended for educational use.  It may not be used
  7.  * for profit without the express written consent of the author.
  8.  *
  9.  * It may be freely redistributed, as long as this notice remains intact
  10.  * and either the original sources or derived sources 
  11.  * are distributed along with any executables derived from the originals.
  12.  *
  13.  * The author is not responsible for any damages that may arise from use
  14.  * of this software, either idirect or consequential.
  15.  *
  16.  * v1.35 March 1997
  17.  * David Lindauer, gclind01@starbase.spd.louisville.edu
  18.  *
  19.  * Credits to Mathew Brandt for original K&R C compiler
  20.  *
  21.  */
  22. #include        <stdio.h>
  23. #include        "expr.h"
  24. #include        "c.h"
  25. #include        "gen68.h"
  26. #include  "diag.h"
  28. extern long lc_maxauto;
  29. extern int linkreg;
  30. extern long framedepth;
  31. extern TYP              stdfunc;
  32. extern struct amode     push[], pop[];
  33. extern OCODE *peep_tail, *peep_head, *peep_insert;
  34. extern long stackdepth;
  35. extern SYM *currentfunc;
  36. extern int prm_cplusplus,prm_linkreg, prm_phiform, prm_68020, prm_68010;
  37. extern int prm_rel, prm_smallcode;
  38. extern long firstlabel, nextlabel;
  39. extern int global_flag;
  40. extern int save_mask, fsave_mask;
  41. extern TABLE gsyms;
  43. static int  diddef;
  44. static int     breaklab;
  45. static int     contlab;
  46. static int     retlab;
  47. static long gswitchbottom, gswitchcount;
  48. static long gswitchtop;
  50. void genstmtini(void)
  51. {
  52. }
  53. AMODE    *makedreg(int r)
  54. /*
  55.  *      make an address reference to a data register.
  56.  */
  57. {       AMODE    *ap;
  58.         ap = xalloc(sizeof(AMODE));
  59.         ap->mode = am_dreg;
  60.         ap->preg = r;
  61.         return ap;
  62. }
  64. AMODE    *makeareg(int r)
  65. /*
  66.  *      make an address reference to an address register.
  67.  */
  68. {       AMODE    *ap;
  69.         ap = xalloc(sizeof(AMODE));
  70.         ap->mode = am_areg;
  71.         ap->preg = r;
  72.         return ap;
  73. }
  75. AMODE    *makefreg(int r)
  76. /*
  77.  *      make an address reference to a data register.
  78.  */
  79. {       AMODE    *ap;
  80.         ap = xalloc(sizeof(AMODE));
  81.         ap->mode = am_freg;
  82.         ap->preg = r;
  83.         return ap;
  84. }
  85. AMODE    *make_mask(int mask, int reverse, int floatflag)
  86. /*
  87.  *      generate the mask address structure.
  88.  */
  89. {       AMODE    *ap;
  90.         ap = xalloc(sizeof(AMODE));
  91. if (floatflag)
  92.          ap->mode = am_fmask;
  93.         else
  94. ap->mode = am_mask;
  95. ap->preg = reverse;
  96.         ap->offset = (ENODE *)mask;
  97.         return ap;
  98. }
  100. AMODE    *make_direct(int i)
  101. /*
  102.  *      make a direct reference to an immediate value.
  103.  */
  104. {       return make_offset(makenode(en_icon,(char *)i,0));
  105. }
  107. AMODE    *make_strlab(char *s)
  108. /*
  109.  *      generate a direct reference to a string label.
  110.  */
  111. {       AMODE    *ap;
  112.         ap = xalloc(sizeof(AMODE));
  113.         ap->mode = am_direct;
  114.         ap->offset = makenode(en_nacon,s,0);
  115.         return ap;
  116. }
  118. void genwhile(SNODE *stmt)
  119. /*
  120.  *      generate code to evaluate a while statement.
  121.  */
  122. {       int     lab1, lab2, lab3;
  123.         initstack();            /* initialize temp registers */
  124.         lab1 = contlab;         /* save old continue label */
  125.         contlab = nextlabel++;  /* new continue label */
  126.         if( stmt->s1 != 0 )      /* has block */
  127.                 {
  128.          lab2 = breaklab;        /* save old break label */
  129.                 breaklab = nextlabel++;
  130. gen_code(op_bra,0,make_label(contlab),0);
  131. lab3 = nextlabel++;
  132. gen_label(lab3);
  133.                 genstmt(stmt->s1);
  134. gen_label(contlab);
  135.                 initstack();
  136. if (stmt->lst)
  137.   gen_line(stmt->lst);
  138.                 truejp(stmt->exp,lab3);
  139.                 gen_label(breaklab);
  140.                 breaklab = lab2;        /* restore old break label */
  141.                 }
  142.         else         /* no loop code */
  143.                 {
  144. if (stmt->lst)
  145.   gen_line(stmt->lst);
  146.          gen_label(contlab);
  147.                 initstack();
  148.                 truejp(stmt->exp,contlab);
  149.                 }
  150.         contlab = lab1;         /* restore old continue label */
  151. }
  153. void gen_for(SNODE *stmt)
  154. /*
  155.  *      generate code to evaluate a for loop
  156.  */
  157. {       int     old_break, old_cont, exit_label, loop_label;
  158.         old_break = breaklab;
  159.         old_cont = contlab;
  160.         loop_label = nextlabel++;
  161.         exit_label = nextlabel++;
  162.         contlab = nextlabel++;
  163.         initstack();
  164.         if( stmt->label != 0 )
  165.                 gen_expr(stmt->label,F_ALL | F_NOVALUE
  166.                         ,natural_size(stmt->label));
  168.         gen_code(op_bra,0,make_label(contlab),0);
  169.         gen_label(loop_label);
  170.         if( stmt->s1 != 0 ) {
  171. breaklab = exit_label;
  172.                 genstmt(stmt->s1);
  173. }
  174.         initstack();
  175.         if( stmt->s2 != 0 )
  176.                 gen_expr(stmt->s2,F_ALL | F_NOVALUE,natural_size(stmt->s2));
  177. gen_label(contlab);
  178. if (stmt->lst)
  179.   gen_line(stmt->lst);
  180.         initstack();
  181.         if( stmt->exp != 0 )
  182.                 truejp(stmt->exp,loop_label);
  183. else
  184. gen_code(op_bra,0,make_label(loop_label),0);
  185. gen_label(exit_label);
  186.   breaklab = old_break;
  187. contlab = old_cont;
  188. }
  190. void genif(SNODE *stmt)
  191. /*
  192.  *      generate code to evaluate an if statement.
  193.  */
  194. {       int     lab1, lab2;
  195.         lab1 = nextlabel++;     /* else label */
  196.         lab2 = nextlabel++;     /* exit label */
  197.         initstack();            /* clear temps */
  198.         falsejp(stmt->exp,lab1);
  199.         genstmt(stmt->s1);
  200.         if( stmt->s2 != 0 )             /* else part exists */
  201.                 {
  202.                 gen_code(op_bra,0,make_label(lab2),0);
  203.                 gen_label(lab1);
  204.                 genstmt(stmt->s2);
  205.                 gen_label(lab2);
  206.                 }
  207.         else                            /* no else code */
  208.                 gen_label(lab1);
  209. }
  211. void gendo(SNODE *stmt)
  212. /*
  213.  *      generate code for a do - while loop.
  214.  */
  215. {       int     oldcont, oldbreak;
  216.         oldcont = contlab;
  217.         oldbreak = breaklab;
  218.         contlab = nextlabel++;
  219.         gen_label(contlab);
  220.         if( stmt->s1 != 0 && stmt->s1->next != 0 )
  221.                 {
  222.                 breaklab = nextlabel++;
  223.                 genstmt(stmt->s1);      /* generate body */
  224.                 initstack();
  225.                 truejp(stmt->exp,contlab);
  226.                 gen_label(breaklab);
  227.                 }
  228.         else
  229.                 {
  230.                 genstmt(stmt->s1);
  231.                 initstack();
  232.                 truejp(stmt->exp,contlab);
  233.                 }
  234.         breaklab = oldbreak;
  235.         contlab = oldcont;
  236. }
  237. void gen_genword(SNODE *stmt)
  238. /*
  239.  * Generate data in the code stream
  240.  */
  241. {
  242. gen_code(op_genword,2,make_immed((int)stmt->exp),0);
  243. }
  244. AMODE *set_symbol(char *name, int isproc)
  245. /*
  246.  *      generate a call to a library routine.
  247.  */
  248. {       SYM     *sp;
  249.         AMODE *result;
  250.         sp = gsearch(name);
  251.         if( sp == 0 )
  252.                 {
  253.                 ++global_flag;
  254.                 sp = xalloc(sizeof(SYM));
  255.                 sp->tp = &stdfunc;
  256.                 sp->name = name;
  257. if (isproc)
  258.                  sp->storage_class = sc_externalfunc;
  259. else
  260.                  sp->storage_class = sc_external;
  261. sp->extflag = TRUE;
  262.                 insert(sp,&gsyms);
  263.                 --global_flag;
  264.                 }
  265. result = make_strlab(name);
  266. return result;
  267. }
  268. AMODE *flush_for_libcall()
  269. {
  270.         AMODE *result = temp_addr();
  271.         temp_addr();                    /* push any used addr temps */
  272.         freeop(result); freeop(result);
  273.         result = temp_data();
  274.         temp_data(); temp_data();      /* push any used data registers */
  275.         freeop(result); freeop(result); freeop(result);
  276. }
  277. AMODE *call_library(char *lib_name,int size)
  278. /*
  279.  *      generate a call to a library routine.
  280.  */
  281. {       
  282.         AMODE *result;
  283. result = set_symbol(lib_name,1);
  284.         gen_code(op_bsr,0,result,0);
  285. if (size)
  286.          gen_code(op_add,4,make_immed(size),makeareg(7));
  287. result = temp_data();
  288. if (result->preg != 0)
  289.          gen_code(op_move,4,makedreg(0),result);
  290. result->tempflag = TRUE;
  291. return result;
  292. }
  294. int analyzeswitch(SNODE *stmt)
  295. /* 
  296.  * Decide whitch type of switch statement to use
  297.  */
  298. {
  299. gswitchbottom = 0x7fffffff;
  300. gswitchtop = -0x80000000;
  301. gswitchcount = 0;
  302. stmt = stmt->s1;
  303. while (stmt) {
  304. if (!stmt->s2) {
  305. gswitchcount++;
  306. if ((int)stmt->label < gswitchbottom)
  307. gswitchbottom = (int)stmt->label;
  308. if ((int)stmt->label > gswitchtop)
  309. gswitchtop = (int)stmt->label;
  310. }
  311. stmt = stmt->next;
  312. }
  313. gswitchtop++;
  314. if (gswitchcount == 0)
  315. return(0);
  316. if (gswitchcount > 3)
  317. if (gswitchcount*10/(gswitchtop-gswitchbottom) >= 8)
  318. return(1);
  319. return(2);
  320. }
  322. void bingen(int lower, int avg, int higher,AMODE *ap1, int deflab, int size, long *switchids, int *switchlabels, int *switchbinlabels)
  323. /*
  324.  * Recursively output the compare/jump tree for a type of binary search
  325.  * on the case value
  326.  */
  327. {
  328. AMODE *ap2 = make_immed(switchids[avg]);
  329. AMODE *ap3 = make_label(switchlabels[avg]);
  330. if (switchbinlabels[avg] != -1)
  331. gen_label(switchbinlabels[avg]);
  332. gen_code(op_cmp,4,ap2,ap1);
  333. gen_code(op_beq,0,ap3,0);
  334. if (avg == lower) {
  335. ap3 = make_label(deflab);
  336. gen_code(op_bra,0,ap3,0);
  337. }
  338. else {
  339. int avg1 = (lower + avg)/2;
  340. int avg2 = (higher + avg+1)/2;
  341. if (avg+1 < higher) 
  342. ap3 = make_label(switchbinlabels[avg2]=nextlabel++);
  343. else
  344. ap3 = make_label(deflab);
  345. if (size < 0)
  346. gen_code(op_bgt,0,ap3,0);
  347. else
  348. gen_code(op_bhi,0,ap3,0);
  349. bingen(lower,avg1,avg,ap1,deflab,size,switchids,switchlabels,switchbinlabels);
  350. if (avg+1 < higher)
  351. bingen(avg+1,avg2,higher,ap1,deflab,size,switchids,switchlabels,switchbinlabels);
  352. }
  353. }
  354. void genbinaryswitch(SNODE *stmt, int deflab)
  355. /*
  356.  * Main routine for handling the binary switch setup
  357.  */
  358. {
  359. int curlab, i=0,j,size = natural_size(stmt->exp);
  360. AMODE *ap1;
  361.   long switchbottom=gswitchbottom, switchcount=gswitchcount;
  362.   long switchtop=gswitchtop;
  363.   int *switchlabels=0;
  364.   long *switchids=0;
  365.   int *switchbinlabels=0;
  366. curlab = nextlabel++;
  367.   initstack();
  368.   ap1 = gen_expr(stmt->exp,F_DREG,4);
  369. global_flag++;
  370. switchlabels = xalloc((switchcount) * sizeof(int));
  371. switchbinlabels = xalloc((switchcount) * sizeof(int));
  372. switchids = xalloc((switchcount) * sizeof(long));
  373. global_flag--;
  374. stmt = stmt->s1;
  375. while (stmt) {
  376.                 if( stmt->s2 )          /* default case ? */
  377.                         {
  378.                         stmt->label = (SNODE *) deflab;
  379. diddef = TRUE;
  380.                         }
  381.                 else
  382.                         {
  383. switchlabels[i] = curlab;
  384. switchbinlabels[i] = -1;
  385. switchids[i++] = (int)stmt->label;
  386. stmt->label = (SNODE *)curlab;
  387.                         }
  388.                 if( stmt->next != 0 )
  389.                         curlab = nextlabel++;
  390.                 stmt = stmt->next;
  391.                 }
  392. for (i=0; i < switchcount; i++)
  393. for (j=i+1; j < switchcount; j++)
  394. if (switchids[j] < switchids[i]) {
  395. int temp = switchids[i];
  396. switchids[i] = switchids[j];
  397. switchids[j] = temp;
  398. temp = switchlabels[i];
  399. switchlabels[i] = switchlabels[j];
  400. switchlabels[j] = temp;
  401. }
  402. bingen(0,(switchcount)/2,switchcount,ap1,deflab,size,switchids,switchlabels,switchbinlabels);
  403. }
  404. void gencompactswitch(SNODE *stmt, int deflab)
  405. /*
  406.  * Generate a table lookup mechanism if the switch table isn't too sparse
  407.  */
  408. {       int             tablab,curlab,i;
  409.         AMODE    *ap,*ap1,*ap2,*ap3;
  410.    long switchbottom=gswitchbottom, switchcount=gswitchcount;
  411.   long switchtop=gswitchtop;
  412.    int *switchlabels=0;
  413. tablab = nextlabel++;
  414.         curlab = nextlabel++;
  415.         initstack();
  416.         ap = gen_expr(stmt->exp,F_DREG | F_VOL,4);
  417. initstack();
  418. if (switchbottom) {
  419. gen_code(op_sub,4,make_immed(switchbottom),ap);
  420. gen_code(op_blo,0,make_label(deflab),0);
  421. }
  422. gen_code(op_cmp,4,make_immed(switchtop-switchbottom),ap);
  423. gen_code(op_bhs,0,make_label(deflab),0);
  424. ap1= temp_addr();
  425. ap2 = xalloc(sizeof(AMODE));
  426. if (prm_rel) {
  427. ap2->preg = ap1->preg;
  428. ap2->mode = am_pcindx;
  429. }
  430. else {
  431. ap2->mode = am_adirect;
  432. if (prm_smallcode)
  433. ap2->preg = 2;
  434. else
  435. ap2->preg = 4;
  436. }
  437. ap2->offset = makenode(en_labcon,(char *)tablab,0);
  438. gen_code(op_lea,0,ap2,ap1);
  439. if (prm_rel || prm_smallcode)
  440. gen_code(op_asl,4,make_immed(1),ap);
  441. else
  442. gen_code(op_asl,4,make_immed(2),ap);
  443. if (prm_rel) {
  444. gen_code(op_add,4,ap,ap1);
  445. ap2->mode = am_ind;
  446. gen_code(op_add,2,ap2,ap1);
  447. }
  448. else {
  449. ap3->sreg = ap->preg;
  450. ap3->preg = ap1->preg;
  451. ap3->scale = 0;
  452. ap3->offset = makenode(en_icon,0,0);
  453. ap3->mode = am_baseindxdata;
  454. gen_code(op_move,4,ap3,ap1);
  455. }
  456. ap1->mode = am_ind;
  457. gen_code(op_jmp,0,ap1,0);
  459. initstack();
  460. gen_label(tablab);
  461. switchlabels = xalloc((switchtop-switchbottom) * sizeof(int));
  462. for (i=switchbottom; i < switchtop; i++) {
  463. switchlabels[i-switchbottom] = deflab;
  464. }
  465. stmt = stmt->s1;
  466. while (stmt) {
  467.                 if( stmt->s2 )          /* default case ? */
  468.                         {
  469.                         stmt->label = (SNODE *)deflab;
  470. diddef = TRUE;
  471.                         }
  472.                 else
  473.                         {
  474. switchlabels[(int)stmt->label-switchbottom] = curlab;
  475. stmt->label = (SNODE *)curlab;
  476.                         }
  477.                 if( stmt->next != 0 )
  478.                         curlab = nextlabel++;
  479.                 stmt = stmt->next;
  480.                 }
  481. for (i=0; i < switchtop-switchbottom; i++)
  482. if (prm_smallcode || prm_rel)
  483. gen_code(op_dcl,2,make_label(switchlabels[i]),0);
  484. else
  485. gen_code(op_dcl,4,make_label(switchlabels[i]),0);
  486. }
  488. void gencase(SNODE *stmt)
  489. /*
  490.  *      generate all cases for a switch statement.
  491.  */
  492. {       while( stmt != 0 )
  493.                 {
  494.                 gen_label((int)stmt->label);
  495.                 if( stmt->s1 != 0 )
  496.                         {
  497.                         genstmt(stmt->s1);
  498.                         }
  499.                 stmt = stmt->next;
  500.                 }
  501. }
  503. void genxswitch(SNODE *stmt)
  504. /*
  505.  *      analyze and generate best switch statement.
  506.  */
  507. {       int     oldbreak;
  508. int olddiddef = diddef;
  509. int deflab = nextlabel++;
  510.         oldbreak = breaklab;
  511.         breaklab = nextlabel++;
  512. diddef = FALSE;
  513. switch (analyzeswitch(stmt)) {
  514.    case 2:
  515. genbinaryswitch(stmt,deflab);
  516. break;
  517. case 1:
  518. gencompactswitch(stmt,deflab);
  519. break;
  520. case 0:
  521. if (stmt->s1)
  522. stmt->s1->label = (SNODE *) nextlabel++;
  523. break;
  524. }
  525.         gencase(stmt->s1);
  526.         gen_label(breaklab);
  527. if (!diddef)
  528.          gen_label(deflab);
  529.         breaklab = oldbreak;
  530. diddef = olddiddef;
  531. }
  533. void genreturn(SNODE *stmt,int flag)
  534. /*
  535.  *      generate a return statement.
  536.  */
  537. {       AMODE    *ap,*ap1,*ap2,*ap3;
  538. int size;
  539.         if( stmt != 0 && stmt->exp != 0 )
  540.         {
  541.                 initstack();
  542. if (currentfunc->tp->btp && currentfunc->tp->btp->type != bt_void && (currentfunc->tp->btp->type == bt_struct || currentfunc->tp->btp->type == bt_union)) {
  543. int lbl;
  544. lbl = nextlabel++;
  545. size = currentfunc->tp->btp->size;
  546.                  ap = gen_expr(stmt->exp,F_AREG | F_VOL,4);
  547. ap2 = xalloc(sizeof(AMODE));
  548. if (prm_linkreg && !currentfunc->intflag) {
  549. if (currentfunc->pascaldefn && currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *)-1) {
  550. ap2->preg = linkreg;
  551. ap2->mode = am_indx;
  552. ap2->offset = makenode(en_icon,(char *)(currentfunc->tp->lst.head->value.i + ((currentfunc->tp->lst.head->tp->size +3) &0xFFFFFFFCL)),0);
  553. }
  554. else {
  555. ap2->preg = linkreg;
  556. ap2->mode = am_indx;
  557. ap2->offset = makenode(en_icon,(char *)8,0);
  558. }
  559. }
  560. else if ( prm_phiform || currentfunc->intflag) {
  561. if (currentfunc->pascaldefn && currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *)-1) {
  562. ap2->preg = linkreg;
  563. ap2->mode = am_indx;
  564. ap2->offset = makenode(en_icon,(char *)(currentfunc->tp->lst.head->value.i + ((currentfunc->tp->lst.head->tp->size +3) &0xFFFFFFFCL)),0);
  565. }
  566. else {
  567.   ap2->preg = linkreg;
  568. ap2->mode = am_ind;
  569. }
  570. }
  571. else {
  572. if (currentfunc->pascaldefn && currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *)-1) {
  573. ap2->preg = 7;
  574. ap2->mode = am_indx;
  575. ap2->offset = makenode(en_icon,(char *)(framedepth+stackdepth+currentfunc->tp->lst.head->value.i + ((currentfunc->tp->lst.head->tp->size+3) & 0xfffffffcL)),0);
  576. }
  577. else {
  578. ap2->preg = 7;
  579. ap2->mode = am_indx;
  580. ap2->offset = makenode(en_icon,(char *)(framedepth+stackdepth),0);
  581. }
  582. }
  583. ap3 = temp_addr();
  584. ap1 = temp_data();
  585. gen_code(op_move,4,ap2,ap3);
  586. ap->mode = am_ainc;
  587. ap3->mode = am_ainc;
  588. gen_code(op_move,4,make_immed(size),ap1);
  589. gen_label(lbl);
  590. gen_code(op_move,1,ap,ap3);
  591. gen_code(op_sub,4,make_immed(1),ap1);
  592. gen_code(op_bne,0,make_label(lbl),0);
  593. gen_code(op_move,4,ap2,makedreg(0));
  594. freeop(ap1);
  595. freeop(ap3);
  596. freeop(ap);
  597. }
  598. else {
  599. size = currentfunc->tp->btp->size;
  600.                  ap = gen_expr(stmt->exp,F_ALL,size);
  601. if (size > 4) {
  602.                   if( ap->mode != am_freg || ap->preg != 0 )
  603.                          gen_codef(op_fmove,size,ap,makefreg(0));
  604. }
  605.                  else
  606.                   if( ap->mode != am_dreg || ap->preg != 0 )
  607.                          gen_code(op_move,size,ap,makedreg(0));
  608. }
  609.         }
  610. if (flag) {
  611.          if( retlab != -1 )
  612.                 gen_label(retlab);
  613. if ((!prm_linkreg || currentfunc->intflag) && (lc_maxauto))
  614. if (lc_maxauto > 8) {
  615. AMODE *ap = xalloc(sizeof(AMODE)); 
  616. ap->mode = am_indx;
  617. ap->offset = makenode(en_icon,(char *)lc_maxauto,0);
  618. ap->preg = 7;
  619.                gen_code(op_lea,0,ap,makeareg(7));
  620. }
  621. else
  622.               gen_code(op_add,4,make_immed(lc_maxauto),makeareg(7));
  623.           if( fsave_mask != 0 )
  624.             gen_code(op_fmovem,10,pop,make_mask(fsave_mask,1,1));
  625.           if( save_mask != 0 )
  626.             gen_code(op_movem,4,pop,make_mask(save_mask,1,0));
  627. if (prm_linkreg && !currentfunc->intflag && (currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *)-1 || lc_maxauto)) {
  628. gen_code(op_unlk,0,makeareg(linkreg),0);
  629. }
  630. if (currentfunc->intflag)
  631.             gen_code(op_rte,0,0,0);
  632. else
  633. if (currentfunc->pascaldefn) {
  634. long retsize = 0;
  635. if (currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *)-1) {
  636. retsize = currentfunc->tp->lst.head->value.i + ((currentfunc->tp->lst.head->tp->size +3) & 0xfffffffcl);
  637. if (prm_linkreg)
  638. retsize -= 8;
  639. } 
  640. if (currentfunc->tp->btp && currentfunc->tp->btp->type != bt_void && (currentfunc->tp->btp->type == bt_struct || currentfunc->tp->btp->type == bt_union)) 
  641. retsize +=4;
  642. if (retsize) {
  643. if (prm_68020 || prm_68010)
  644. gen_code(op_rtd,0,make_immed(retsize),0);
  645. else {
  646. ap = temp_addr();
  647. freeop(ap);
  648. gen_code(op_move,4,pop,ap);
  649. if (retsize > 8) {
  650. ap1 = xalloc(sizeof(AMODE));
  651. ap1->mode = am_indx;
  652. ap1->offset = makenode(en_icon,(char *)retsize,0);
  653. ap1->preg = 7;
  654.                  gen_code(op_lea,0,ap1,makeareg(7));
  655. }
  656. else
  657.                  gen_code(op_add,4,make_immed(retsize),makeareg(7));
  658. ap->mode = am_ind;
  659. gen_code(op_jmp,0,ap,0);
  660. }
  661. return;
  662. }
  663. }
  664.             gen_code(op_rts,0,0,0);
  665.         }
  666.         else {
  667. if (retlab == -1)
  668. retlab = nextlabel++;
  669.           gen_code(op_bra,0,make_label(retlab),0);
  670. }
  671. }
  673. void genstmt(SNODE *stmt)
  674. /*
  675.  *      genstmt will generate a statement and follow the next pointer
  676.  *      until the block is generated.
  677.  */
  678. {
  679.    while( stmt != 0 )
  680.                 {
  681.                 switch( stmt->stype )
  682.                         {
  683. case st_block:
  684. genstmt(stmt->exp);
  685. break;
  686.                         case st_label:
  687.                                 gen_label((int)stmt->label);
  688.                                 break;
  689.                         case st_goto:
  690.                                 gen_code(op_bra,0,make_label((int)stmt->label),0);
  691.                                 break;
  692.                         case st_expr:
  693.                                 initstack();
  694.                                 gen_expr(stmt->exp,F_ALL | F_NOVALUE,
  695.                                         natural_size(stmt->exp));
  696.                                 break;
  697.                         case st_return:
  698.                                 genreturn(stmt,0);
  699.                                 break;
  700.                         case st_if:
  701.                                 genif(stmt);
  702.                                 break;
  703.                         case st_while:
  704.                                 genwhile(stmt);
  705.                                 break;
  706.                         case st_do:
  707.                                 gendo(stmt);
  708.                                 break;
  709.                         case st_for:
  710.                                 gen_for(stmt);
  711.                                 break;
  712. case st_line:
  713. gen_line(stmt);
  714. break;
  715.                         case st_continue:
  716.                                 gen_code(op_bra,0,make_label(contlab),0);
  717.                                 break;
  718.                         case st_break:
  719.   gen_code(op_bra,0,make_label(breaklab),0);
  720.                                 break;
  721.                         case st_switch:
  722.                                 genxswitch(stmt);
  723.                                 break;
  724. case st__genword:
  725. gen_genword(stmt);
  726. break;
  727.                         default:
  728.                                 DIAG("unknown statement.");
  729.                                 break;
  730.                         }
  731.                 stmt = stmt->next;
  732.                 }
  733. }
  734. #ifdef CPLUSPLUS
  735. void scppinit(void)
  736. /*
  737.  * Call C++ reference variable and class initializers
  738.  */
  739. {
  740. if (!strcmp(currentfunc->name,"_main")) {
  741. AMODE *ap1,*ap2,*ap3,*ap4;
  742. int lbl = nextlabel++;
  743. initstack();
  744. ap1 = temp_addr();
  745. ap4 = xalloc(sizeof(AMODE));
  746. ap4->preg = ap1->preg;
  747. ap4->mode = am_ind;
  748. ap2 = set_symbol("CPPSTART",0);
  749. ap3 = set_symbol("CPPEND",0);
  750. gen_code(op_lea,4,ap2,ap1);
  751. gen_label(lbl);
  752. gen_code(op_move,4,ap1,push);
  753. gen_code(op_jsr,4,ap4,0);
  754. gen_code(op_move,4,pop,ap1);
  755. gen_code(op_add,4,make_immed(4),ap1);
  756. gen_code(op_cmp,4,ap3,ap1);
  757. gen_code(op_bhi,0,make_label(lbl),0);
  758. freeop(ap1);
  759. }
  760. }
  761. #endif
  762. void genfunc(SNODE *stmt)
  763. /*
  764.  *      generate a function body.
  765.  */
  766. {       retlab = contlab = breaklab = -1;
  767. stackdepth = 0;
  768. if (stmt->stype == st_line) {
  769. gen_line(stmt);
  770. stmt = stmt->next;
  771. }
  772. gen_codelab(currentfunc);  /* name of function */
  773.         opt1(stmt); /* push args & Also loads link reg and subtracts SP */
  774. #ifdef CPLUSPLUS
  775. if (prm_cplusplus) {
  776. scppinit();
  777. }
  778. #endif
  779.         genstmt(stmt);
  780.         genreturn(0,1);
  781. }