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

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

编译器/解释器

开发平台：

Others

AN386.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. /*
  23.  * Register analysis
  24.  */
  25. #include        <stdio.h>
  26. #include        "expr.h"
  27. #include        "c.h"
  28. #include        "gen386.h"
  29. #include  "diag.h"
  31. /* pc-relative expressions not optimized */
  32. extern AMODE    push[], pop[];
  33. extern OCODE    *peep_tail;
  34. extern SYM *currentfunc;
  35. extern int prm_stackcheck,prm_linkreg;
  36. extern int floatregs,dataregs,addrregs;
  37. extern long framedepth,stackdepth;
  38. extern int cf_maxfloat, cf_maxaddress,cf_maxdata,cf_freeaddress,cf_freedata,cf_freefloat;
  39. extern CSE       *olist;         /* list of optimizable expressions */
  41. long lc_maxauto;
  42. int  fsave_mask,save_mask;
  43. void reserveregs(int *datareg, int *addreg, int *floatreg)
  44. /*
  45.  * Reserve regs goes through and reserves a register for variables with
  46.  * the REGISTER keyword.  Note that it currently does register allocation
  47.  * backwards...  NOT the standard I suspect.
  48.  */
  49. {
  50. CSE *csp = olist;
  52. while (csp) {
  53. switch (csp->exp->nodetype) {
  54. case en_floatref:
  55. case en_doubleref:
  56. case en_longdoubleref:
  57. break;
  58.                 case en_b_ref:
  59.                 case en_w_ref:
  60.                 case en_l_ref:
  61.                 case en_ub_ref:
  62.                 case en_uw_ref:
  63. case en_ul_ref:
  64. if (csp->exp->v.p[0]->nodetype != en_autoreg)
  65. break;
  66.    if (csp->exp->nodetype == en_floatref || csp->exp->nodetype == en_doubleref 
  67. || csp->exp->nodetype == en_longdoubleref) {
  68. }
  69.                  else if( (csp->duses <= csp->uses / 4) && (*datareg < cf_maxdata) &&dataregs)
  70.                         csp->reg = (*datareg)++;
  71.                 else if(!(csp->size ==-1 || csp->size ==1) && (*addreg < cf_maxaddress) && addrregs) {
  72.                         csp->reg = (*addreg)++;
  73. }
  74. if (csp->reg != -1) {
  75. ((SYM *)csp->exp->v.p[0]->v.p[0])->inreg = TRUE;
  76. ((SYM *)csp->exp->v.p[0]->v.p[0])->value.i = -csp->reg;
  77. }
  78. break;
  79. }
  80. csp = csp->next;
  81. }
  82. }
  84. void allocate(int datareg, int addreg, int floatreg, SNODE *block )
  85. /*
  86.  *      allocate will allocate registers for the expressions that have
  87.  *      a high enough desirability.  It also puts the function
  88.  * header, consisting of saved registers and stack decrments for local
  89.  * variables
  90.  */
  91. {       CSE      *csp;
  92.         ENODE    *exptr;
  93.         unsigned      mask, rmask,i,fmask,frmask,size;
  94.         AMODE    *ap, *ap2;
  95. framedepth = 4;
  96.         mask = 0;
  97. rmask = 0;
  98. fmask = frmask = 0;
  99. for (i=cf_freedata; i < datareg; i++) {
  100. rmask = rmask | (1 << (15 - i));
  101.                         mask = mask | (1 << i);
  102. }
  103. for (i=cf_freeaddress+16; i < addreg; i++) {
  104. rmask = rmask | (1 << (23 - i));
  105.                         mask = mask | (1 << (i-8));
  106. }
  107.         while( bsort(&olist) );         /* sort the expression list */
  108.         csp = olist;
  109.         while( csp != 0 ) {
  110. if (csp->reg == -1 && !(csp->exp->cflags & DF_VOL) && !csp->voidf) {
  111.                 if( desire(csp) < 3 )
  112.                         csp->reg = -1;
  113. else {
  114. if (csp->exp->nodetype == en_rcon || csp->exp->nodetype == en_fcon || csp->exp->nodetype == en_lrcon
  115.    || csp->exp->nodetype == en_floatref || csp->exp->nodetype ==en_doubleref
  116. || csp->exp->nodetype == en_longdoubleref) {
  117. }
  118.              else if( (csp->duses <= csp->uses / 4) && (datareg < cf_maxdata) &&dataregs)
  119.                    csp->reg = (datareg)++;
  120.                 else if( (!(csp->size == 1 || csp->size == -1) || csp->exp->nodetype == en_icon) && (addreg < cf_maxaddress) && addrregs) {
  121.                    csp->reg = (addreg)++;
  122. }
  123. }
  124. }
  125.             if( csp->reg != -1 )
  126. {
  127. if (lvalue(csp->exp) && !((SYM *)csp->exp->v.p[0]->v.p[0])->funcparm) {
  128. ((SYM *)csp->exp->v.p[0]->v.p[0])->inreg = TRUE;
  129. ((SYM *)csp->exp->v.p[0]->v.p[0])->value.i = -csp->reg;
  130. }
  131. if (csp->reg < 16) {
  132. rmask = rmask | (1 << (15 - csp->reg));
  133.                         mask = mask | (1 << csp->reg);
  134. }
  135. if (csp->reg < 32) {
  136. rmask = rmask | (1 << (23 - csp->reg));
  137.                         mask = mask | (1 << (csp->reg-8));
  138. }
  139. else {
  140. frmask = frmask | (1 << (39 - csp->reg));
  141.               fmask = fmask | (1 << (csp->reg-32));
  142. }
  143. }
  144.                 csp = csp->next;
  145.                 }
  146. allocstack(); /* Allocate stack space for the local vars */
  147. if (prm_linkreg && (lc_maxauto || currentfunc->tp->lst.head && currentfunc->tp->lst.head != (SYM *)-1)) {
  148. gen_code(op_enter,4,make_immed(lc_maxauto),make_immed(0));
  149. }
  150. if (currentfunc->intflag) {
  151. gen_code(op_pushad,0,0,0);
  152. stackdepth = 4*8;
  153. }
  154.         else
  155.   if( mask != 0 ) 
  156. pushregs(rmask);
  157.         save_mask = mask;
  158. if (fmask!=0)
  159. fsave_mask = fmask;
  161. if (!prm_linkreg && lc_maxauto) {
  162. gen_code(op_sub,4,makedreg(ESP), make_immed(lc_maxauto));
  163. }
  164. stackdepth +=lc_maxauto;
  165. framedepth +=stackdepth;
  166. stackdepth = 0;
  167. if (prm_stackcheck) {
  168. AMODE *ap1;
  169. ap = set_symbol("_stackerror",1);
  170. ap1 = set_symbol("_stackbottom",0);
  171. ap1->mode = am_direct;
  172. gen_code(op_cmp,4,makedreg(ESP),ap1);
  173. gen_code(op_jb,0,ap,0);
  174. }
  175. }
  176. void loadregs(void)
  177. /*
  178.  * initialize allocated registers
  179.  */
  180. {       CSE      *csp;
  181.         ENODE    *exptr;
  182.         unsigned      mask, rmask,i,fmask,frmask,size;
  183.         AMODE    *ap, *ap2;
  184.         csp = olist;
  185.         while( csp != 0 ) {
  186. int sz;
  187.                 if( csp->reg != -1 )
  188.                         {               /* see if preload needed */
  189.                         exptr = csp->exp;
  190.                         if( !lvalue(exptr) || ((SYM *)exptr->v.p[0]->v.p[0])->funcparm )
  191.                                 {
  192. exptr = csp->exp;
  193.                                 initstack();
  194. sz = csp->size;
  195.                                 ap = gen_expr(exptr,F_ALL,sz);
  196.                                 if( csp->reg < 16 ) {
  197. if (ap->mode == am_dreg)
  198. peep_tail->oper1->preg = csp->reg;
  199. else {
  200.                                         ap2 = makedreg(csp->reg);
  201. if (ap->mode == am_immed || sz == 4 || sz == -4)
  202.                                  gen_code(op_mov,4,ap2,ap);
  203. else
  204. if (sz < 0)
  205. gen_code2(op_movsx,-4,sz,ap2,ap);
  206. else
  207. gen_code2(op_movzx,4,sz,ap2,ap);
  208. }
  209. }
  210.                                 else
  211. if (csp->reg < 32) {
  212. if (ap->mode == am_dreg)
  213. peep_tail->oper1->preg = csp->reg - 12;
  214. else {
  215.                                          ap2 = makedreg(csp->reg - 12);
  216. if (ap->mode == am_immed || sz == 4 || sz == -4)
  217.                                   gen_code(op_mov,4,ap2,ap);
  218. else
  219. if (sz < 0)
  220. gen_code2(op_movsx,-4,sz,ap2,ap);
  221. else
  222. gen_code2(op_movzx,4,sz,ap2,ap);
  223. }
  224. }
  225. else {
  226. /* Should never get here */
  227. DIAG("float reg assigned in analyze");
  228. }
  229.                                 freeop(ap);
  230. if (lvalue(exptr) && ((SYM *)exptr->v.p[0]->v.p[0])->funcparm) {
  231. ((SYM *)exptr->v.p[0]->v.p[0])->inreg = TRUE;
  232. ((SYM *)exptr->v.p[0]->v.p[0])->value.i = -csp->reg;
  233. }
  234.                                 }
  235.                         }
  236.                 csp = csp->next;
  237.                 }
  238. }
  239. void asm_scannode (ENODE *node)
  240. {
  241. CSE *csp;
  242. if (node->nodetype == en_add) {
  243. asm_scannode(node->v.p[0]);
  244. asm_scannode(node->v.p[1]);
  245. }
  246. else {
  247. switch (node->nodetype) {
  248.                 case en_icon:
  249. case en_lcon:
  250. case en_iucon:
  251. case en_lucon:
  252. case en_ccon:
  253.                         break;
  254.                 case en_napccon:
  255.                 case en_nacon:
  256. case en_absacon:
  257.                 case en_autocon:
  258.                 case en_autoreg:
  259. csp = enternode(node,0,0);
  260. csp->voidf = TRUE;
  261.                         break;
  262. case en_labcon: case en_nalabcon:
  263. break;
  264. default:
  265. DIAG("Invalid node in assembler line");
  266. break;
  267. }
  268. }
  269. }
  270. void asm_scan1(AMODE *ap)
  271. {
  272. if (!ap || !ap->offset)
  273. return;
  274. asm_scannode(ap->offset);
  275. }
  276. void asm_scan(OCODE *cd)
  277. {
  278. asm_scan1(cd->oper1);
  279. asm_scan1(cd->oper2);
  280. asm_scan1(cd->oper3);
  281. }
  282. void asm_repnode(ENODE **node)
  283. {
  284. if ((*node)->nodetype == en_add) {
  285. asm_repnode(&(*node)->v.p[0]);
  286. asm_repnode(&(*node)->v.p[1]);
  287. }
  288. else
  289.         if( (*node)->nodetype == en_autocon  || (*node)->nodetype == en_autoreg)
  290.                 {
  291. if (prm_linkreg) {
  292.             *node = makenode(en_icon,(char *)((SYM *)(*node)->v.p[0])->value.i,0);
  293. }
  294. else if (((SYM *)(*node)->v.p[0])->funcparm)
  295.                  *node = makenode(en_icon,(char *)(((SYM *)(*node)->v.p[0])->value.i+framedepth+stackdepth),0);
  296.                 else
  297. *node = makenode(en_icon,(char *)(((SYM *)(*node)->v.p[0])->value.i+stackdepth+lc_maxauto),0);
  298.                 }
  299.         else if( (*node)->nodetype == en_nacon || (*node)->nodetype == en_napccon)
  300.                 {
  301.                 *node = makenode((*node)->nodetype,(char *)((SYM *)(*node)->v.p[0])->name,0);
  302.                 }
  303.         else if( (*node)->nodetype == en_nalabcon)
  304.                 {
  305.                 *node = makenode((*node)->nodetype,(char *)(*node)->v.i,0);
  306.                 }
  307.         else if( (*node)->nodetype == en_labcon)
  308.                 {
  309.                 *node = makenode((*node)->nodetype,(char *)(*node)->v.i,0);
  310.                 }
  311. else if ((*node)->nodetype == en_absacon) {
  312. *node = makenode(en_absacon,(char *)((SYM *)(*node)->v.p[0])->value.i,0);
  314. }
  315. }
  316. int voidexpr(ENODE *node)
  317. {       CSE      *csp;
  318.         if( node == 0 )
  319.                 return 0;
  320.         switch( node->nodetype ) {
  321.                 case en_rcon: case en_lrcon: case en_fcon:
  322. return 1;
  323.                 case en_icon:
  324. case en_lcon:
  325. case en_iucon:
  326. case en_lucon:
  327. case en_ccon:
  328.                 case en_nacon:
  329.                 case en_napccon:
  330. case en_absacon:
  331.                 case en_autocon:
  332. case en_autoreg:
  333. return 0;
  334. case en_floatref:
  335. case en_doubleref:
  336. case en_longdoubleref:
  337. return 1;
  338.                 case en_ub_ref:
  339.                 case en_uw_ref:
  340.                 case en_b_ref:
  341.                 case en_w_ref:
  342.                 case en_l_ref:
  343.                 case en_ul_ref:
  344. return 0;
  345.                 case en_uminus: case en_bits:
  346.                 case en_not:    case en_compl:
  347.                 case en_ainc:   case en_adec:
  348.                         return voidexpr(node->v.p[0]);
  349. case en_cb: case en_cub:
  350. case en_cw: case en_cuw:
  351. case en_cl: case en_cul:
  352. case en_cf: case en_cd: case en_cp: case en_cld:
  353.                         return voidexpr(node->v.p[0]);
  354.                 case en_add:    case en_sub:
  355.                 case en_umul:    case en_udiv: case en_umod:
  356.                 case en_mul:    case en_div:
  357.                 case en_mod:    case en_lsh:
  358. case en_asalsh: case en_asarsh: case en_alsh: case en_arsh:
  359.                 case en_rsh:    case en_and:
  360.                 case en_or:     case en_xor:
  361.                 case en_land:   case en_lor:
  362.                 case en_eq:     case en_ne:
  363.                 case en_lt:     case en_le:
  364. case en_ugt: case en_uge: case en_ult: case en_ule:
  365.                 case en_gt:     case en_ge:
  366.                 case en_cond:   case en_void:
  367. case en_pmul:
  368.                 case en_fcall: case en_trapcall: case en_pdiv:
  369. case en_pfcall: case en_pfcallb:
  370.                 case en_intcall: case en_fcallb:
  371.                 case en_moveblock: case en_stackblock: case en_callblock:
  372. case en_pcallblock:
  373.                         return voidexpr(node->v.p[0]) || voidexpr(node->v.p[1]);
  374.                 case en_asadd:  case en_assub:
  375.                 case en_asmul:  case en_asdiv:
  376.                 case en_asor:   case en_asand:   case en_asxor:
  377.                 case en_asmod:  case en_aslsh:
  378. case en_asumod: case en_asudiv: case en_asumul:
  379.                 case en_asrsh: case en_assign: case en_refassign:
  380. if (voidexpr(node->v.p[1])) {
  381. csp = searchnode(node->v.p[0]);
  382. if (csp)
  383. csp->voidf = 1;
  384. }
  385. return voidexpr(node->v.p[0]);
  386. default:
  387. return 0;
  388.                 }
  390. }
  391. void voidfloat(SNODE *block)
  392. /*
  393.  * Scan through a block and void all CSEs which do asadd, asmul, asmodiv
  394.  * of float to int
  395.  */
  396. {       while( block != 0 ) {
  397.                 switch( block->stype ) {
  398.                         case st_return:
  399.                         case st_expr:
  400.                                 voidexpr(block->exp);
  401.                                 break;
  402.                         case st_while:
  403.                         case st_do:
  404.                                 voidexpr(block->exp);
  405.                                 voidfloat(block->s1);
  406.                                 break;
  407.                         case st_for:
  408.                                 voidexpr(block->label);
  409.                                 voidexpr(block->exp);
  410.                                 voidfloat(block->s1);
  411.                                 voidexpr(block->s2);
  412.                                 break;
  413.                         case st_if:
  414.                                 voidexpr(block->exp);
  415.                                 voidfloat(block->s1);
  416.                                 voidfloat(block->s2);
  417.                                 break;
  418.                         case st_switch:
  419.                                 voidexpr(block->exp);
  420.                                 voidfloat(block->s1);
  421.                                 break;
  422.                         case st_case:
  423.                                 voidfloat(block->s1);
  424.                                 break;
  425. case st_block:
  426. voidfloat(block->exp);
  427. break;
  428.                         }
  429.                 block = block->next;
  430.                 }
  431. }
  432. void asm_repcse1(AMODE *ap)
  433. {
  434. if (!ap || !ap->offset)
  435. return;
  436. asm_repnode(&ap->offset);
  437. }
  438. void asm_repcse(OCODE *cd)
  439. {
  440. asm_repcse1(cd->oper1);
  441. asm_repcse1(cd->oper2);
  442. asm_repcse1(cd->oper3);
  443. }