home *** CD-ROM | disk | FTP | other *** search
/ Amiga ACS 1998 #4 / amigaacscoverdisc1998-041998.iso / utilities / shareware / dev / vbcc / supp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-12-30  |  12.8 KB  |  417 lines
  1. #include "supp.h"
  2.  
  3. static char FILE_[]=__FILE__;
  4.  
  5. char *typname[]={"strange","char","short","int","long","float","double","void",
  6.                  "pointer","array","struct","union","enum","function"};
  7. char *storage_class_name[]={"strange","auto","register","static","extern","typedef"};
  8.  
  9. char *ename[]={"strange","sequence","move","set+","set-","set*","set/","set%",
  10.                "set&","set^","set|","set<<","set>>","?:","lor","land","or",
  11.                "eor","and","equal","unequal","lt","le","gt","ge","lsl",
  12.                "lsr","add","sub","mul","div","mod","negate",
  13.                "not","preinc","postinc","predec","postdec","neg",
  14.                "dref-pointer","address-of","cast","call","index",
  15.                "dref-struct-pointer","dref-struct","identifier","constant",
  16.                "string","member",
  17.                 "convert-char","convert-short","convert-int","convert-long",
  18.                 "convert-float","convert-double","convert-void","convert-pointer",
  19.                 "convert-uchar","convert-ushort","convert-uint","convert-ulong",
  20.                 "address-of-array","first-element-of-array","pmult",
  21.                 "allocreg","freereg","pconstant","test","label","beq","bne",
  22.                 "blt","bge","ble","bgt","bra","compare","push","pop",
  23.                 "address-of-struct","add-int-to-pointer","sub-int-from-pointer",
  24.                 "sub-pointer-from-pointer","push-reg","pop-reg","pop-args",
  25.                 "save-regs","restore-regs","identifier-label","dc","align",
  26.                 "colon","get-return","set-return","move-from-reg","move-to-reg",
  27.                 "nop"};
  28.  
  29. char *empty="";
  30. zchar vchar; zuchar vuchar;
  31. zshort vshort; zushort vushort;
  32. zint vint; zuint vuint;
  33. zlong vlong; zulong vulong;
  34. zfloat vfloat; zdouble vdouble;
  35. zpointer vpointer;
  36.  
  37. #ifndef DEBUG
  38. int DEBUG;
  39. #endif
  40.  
  41. int label;
  42.  
  43. int regs[MAXR+1],regused[MAXR+1];
  44. struct Var *regsv[MAXR+1];
  45. int goto_used;
  46. int ic_count;
  47. zlong max_offset;
  48. int function_calls;
  49. int multiple_ccs;
  50. int lastlabel,return_label;
  51. int only_inline;
  52. struct IC *err_ic;
  53. long maxoptpasses=10;
  54. long optflags;
  55. long inline_size=100;
  56. long unroll_size=200;
  57. long fp_assoc,noaliasopt;
  58. int fline;
  59. char errfname[FILENAME_MAX+1];
  60. struct IC *first_ic,*last_ic;
  61. int float_used;
  62. /*  Das haette ich gern woanders    */
  63. struct Var *vl1,*vl2,*vl3;
  64.  
  65.  
  66. struct Typ *clone_typ(struct Typ *old)
  67. /*  Erzeugt Kopie eines Typs und liefert Zeiger auf Kopie.  */
  68. {
  69.   struct Typ *new;
  70.   if(!old) return(0);
  71.   new=mymalloc(TYPS);
  72.   *new=*old;
  73.   if(new->next) new->next=clone_typ(new->next);
  74.   return(new);
  75. }
  76. void free_IC(struct IC *p)
  77. /*  Gibt IC-Liste inkl. Typen frei.                 */
  78. {
  79.   struct IC *merk;
  80.   if(DEBUG&1) printf("free_IC()\n");
  81.   while(p){
  82.     if(p->q1.am) free(p->q1.am);
  83.     if(p->q2.am) free(p->q2.am);
  84.     if(p->z.am) free(p->z.am);
  85.     merk=p->next;
  86.     free(p);
  87.     p=merk;
  88.   }
  89. }
  90. void remove_IC(struct IC *p)
  91. /*  Entfernt IC p aus Liste. */
  92. {
  93.   if(p->prev) p->prev->next=p->next; else first_ic=p->next;
  94.   if(p->next) p->next->prev=p->prev; else last_ic=p->prev;
  95.   if(p->q1.am) free(p->q1.am);
  96.   if(p->q2.am) free(p->q2.am);
  97.   if(p->z.am) free(p->z.am);
  98.   free(p);
  99. }
  100. void freetyp(struct Typ *p)
  101. /* Gibt eine Typ-Liste frei, aber keine struct_declaration oder so. */
  102. {
  103.   int f;struct Typ *merk;
  104.   if(DEBUG&8){printf("freetyp: ");prd(stdout,p);printf("\n");}
  105.   while(p){
  106.     merk=p->next;
  107.     f=p->flags&NQ;
  108.     if(merk&&f!=ARRAY&&f!=POINTER&&f!=FUNKT){ierror(0);return;}
  109.     free(p);
  110.     p=merk;
  111.   }
  112. }
  113. zlong falign(struct Typ *t)
  114. /*  Liefert Alignment eines Typs. Funktioniert im Gegensatz zum  */
  115. /*  align[]-Array auch mit zusammengesetzten Typen.              */
  116. {
  117.   int i,f; zlong al,alt;
  118.   f=t->flags&NQ;
  119.   al=align[f];
  120.   if(f<=POINTER) return al;
  121.   if(f==ARRAY){
  122.     do{ 
  123.       t=t->next; 
  124.       f=t->flags&NQ;
  125.     }while(f==ARRAY);
  126.     alt=falign(t);
  127.     if(zlleq(al,alt)) return alt; else return al;
  128.   }
  129.   if(f==UNION||f==STRUCT){
  130.     for(i=0;i<t->exact->count;i++){
  131.       alt=falign((*t->exact->sl)[i].styp);
  132.       if(!zlleq(alt,al)) al=alt;
  133.     }
  134.     return al;
  135.   }
  136.   return al;
  137. }
  138. zlong szof(struct Typ *t)
  139. /*  Liefert die benoetigte Groesse eines Typs in Bytes.     */
  140. {
  141.   int i=t->flags&NQ,j;zlong size,m;
  142.   if(i<=POINTER) return sizetab[i];
  143.   if(i==ARRAY){
  144.     size=zlmult((t->size),szof(t->next));
  145.     m=align[ARRAY];
  146.     return zlmult(zldiv(zladd(size,zlsub(m,l2zl(1L))),m),m); /* align */
  147.   }
  148.   if(i==UNION){
  149.     for(j=0,size=l2zl(0L);j<t->exact->count;j++){
  150.       m=szof((*t->exact->sl)[j].styp);
  151.       if(zleqto(m,l2zl(0L))) return(l2zl(0L));
  152.       if(!zlleq(m,size)) size=m;
  153.     }
  154.     m=falign(t);
  155.     return zlmult(zldiv(zladd(size,zlsub(m,l2zl(1L))),m),m); /* align */
  156.   }
  157.   if(i==STRUCT){
  158.     for(j=0,size=0;j<t->exact->count;j++){
  159.       struct Typ *h=(*t->exact->sl)[j].styp;
  160.       m=falign(h);
  161.       size=zlmult(zldiv(zladd(size,zlsub(m,l2zl(1L))),m),m);
  162.       m=szof(h);
  163.       if(zleqto(m,l2zl(0L))) return(l2zl(0L));
  164.       size=zladd(size,m);
  165.     }
  166.     m=falign(t);
  167.     return zlmult(zldiv(zladd(size,zlsub(m,l2zl(1L))),m),m); /* align */
  168.   }
  169.   return sizetab[i];
  170. }
  171. void printval(FILE *f,union atyps *p,int t,int verbose)
  172. /*  Gibt atyps aus.                                     */
  173. {
  174.   if(t==CHAR){if(verbose)fprintf(f,"C");vlong=zc2zl(p->vchar);printzl(f,vlong);}
  175.   if(t==(UNSIGNED|CHAR)){if(verbose)fprintf(f,"UC");vulong=zuc2zul(p->vuchar);printzul(f,vulong);}
  176.   if(t==SHORT){if(verbose)fprintf(f,"S");vlong=zs2zl(p->vshort);printzl(f,vlong);}
  177.   if(t==(UNSIGNED|SHORT)){if(verbose) fprintf(f,"US");vulong=zus2zul(p->vushort);printzul(f,vulong);}
  178.   if(t==FLOAT){if(verbose)fprintf(f,"F");vdouble=zf2zd(p->vfloat);printzd(f,vdouble);}
  179.   if(t==DOUBLE){if(verbose)fprintf(f,"D");printzd(f,p->vdouble);}
  180.   if(t==INT){if(verbose)fprintf(f,"I");vlong=zi2zl(p->vint);printzl(f,vlong);}
  181.   if(t==LONG){if(verbose)fprintf(f,"L");printzl(f,p->vlong);}
  182.   if(t==(UNSIGNED|INT)){if(verbose)fprintf(f,"UI");vulong=zui2zul(p->vuint);printzul(f,vulong);}
  183.   if(t==(UNSIGNED|LONG)){if(verbose)fprintf(f,"UL");printzul(f,p->vulong);}
  184.   /*  das hier ist nicht wirklich portabel    */
  185.   if(t==POINTER){if(verbose)fprintf(f,"P");vulong=zp2zul(p->vpointer);printzul(f,vulong);}
  186. }
  187. void pric2(FILE *f,struct IC *p)
  188. /*  Gibt ein IC aus.  */
  189. {
  190.   if(p->next&&p->next->prev!=p) ierror(0);
  191.   if(p->code>=LABEL&&p->code<=BRA){
  192.     if(p->code==LABEL)
  193.       fprintf(f,"L%d",p->typf);
  194.     else{
  195.       fprintf(f,"\t%s L%d",ename[p->code],p->typf);
  196.       if(p->q1.flags){ fprintf(f,",");probj(f,&p->q1,0);}
  197.     }
  198.   }else{
  199.     fprintf(f,"\t%s ",ename[p->code]);
  200.     if(p->typf&UNSIGNED) fprintf(f,"unsigned ");
  201.     if(p->typf) fprintf(f,"%s ",typname[p->typf&NQ]);
  202.     probj(f,&p->q1,p->typf);
  203.     if(p->q2.flags){fprintf(f,",");probj(f,&p->q2,p->typf);}
  204.     if(p->z.flags){fprintf(f,"->");probj(f,&p->z,p->typf);}
  205.     if(p->code==ASSIGN||p->code==PUSH||p->code==POP) fprintf(f," size=%ld",zl2l(p->q2.val.vlong));
  206.     if((p->code==SAVEREGS||p->code==RESTOREREGS)&&p->q1.reg) fprintf(f," except %s",regnames[p->q1.reg]);
  207.   }
  208.   fprintf(f,"\n");
  209. }
  210. void pric(FILE *f,struct IC *p)
  211. /*  Gibt IC-Liste auf dem Bildschirm aus.             */
  212. {
  213.   while(p){
  214.     pric2(f,p);
  215. /*        if(p->q1.am||p->q2.am||p->z.am) ierror(0);*/
  216.     p=p->next;
  217.   }
  218. }
  219. void printzl(FILE *f,zlong x)
  220. /*  Konvertiert zlong nach ASCII.                       */
  221. /*  Basiert noch einigermassen auf                      */
  222. /*  Zweierkomplementdarstellung (d.h. -MIN>MAX).        */
  223. /*  Ausserdem muss max(abs(long))<=max(unsigned long).  */
  224. {
  225.   zlong zl;zulong zul;
  226.   zl=l2zl(0L);
  227.   if(zlleq(x,zl)&&!zleqto(x,l2zl(0L))){
  228.     fprintf(f,"-");zl=zul2zl(t_max[LONG]);
  229.     if(zlleq(x,zlsub(l2zl(0L),zl))&&!zleqto(x,zlsub(l2zl(0L),zl))){
  230.       /*  aufpassen, da -x evtl. >LONG_MAX    */
  231.       zul=t_max[LONG];
  232.       x=zladd(x,zl);
  233.     } else zul=ul2zul(0UL);
  234.     x=zlsub(l2zl(0L),x);
  235.     vulong=zl2zul(x);
  236.     zul=zuladd(zul,vulong);
  237.   }else zul=zl2zul(x);
  238.   printzul(f,zul);
  239. }
  240. void printzul(FILE *f,zulong x)
  241. /*  Konvertiert zulong nach ASCII.                      */
  242. {
  243.   zulong zul;unsigned long l;
  244.   zul=ul2zul(10UL);
  245.   if(!zuleqto(zuldiv(x,zul),ul2zul(0UL))) printzul(f,zuldiv(x,zul));
  246.   zul=zulmod(x,zul);l=zul2ul(zul);
  247.   fprintf(f,"%c",(int)(l+'0'));
  248. }
  249. void printzd(FILE *f,zdouble x)
  250. /*  Konvertiert zdouble nach ASCII, noch nicht fertig.  */
  251. {
  252.   fprintf(f,"fp-constant");
  253. }
  254. void *mymalloc(size_t size)
  255. /*  Belegt Speicher mit Abfrage.    */
  256. {
  257.   void *p;static int safe;
  258.   /*  Um ein Fehlschlagen bei size==0 zu vermeiden; nicht sehr schoen,    */
  259.   /*  aber das einfachste...                                              */
  260.   if(size==0) size=1;
  261.   if(!(p=malloc(size))){
  262.     error(12);
  263.     raus();
  264.   }
  265.   return(p);
  266. }
  267. void probj(FILE *f,struct obj *p,int t)
  268. /*  Gibt Objekt auf Bildschirm aus.                    */
  269. {
  270.   if(p->am) ierror(0);
  271.   if(p->flags&DREFOBJ) fprintf(f,"(");
  272.   if(p->flags&VARADR) fprintf(f,"#");
  273.   if(p->flags&VAR) {
  274.     printval(f,&p->val,LONG,1);
  275.     if(p->v->storage_class==AUTO||p->v->storage_class==REGISTER){
  276.       if(p->flags®)
  277.     fprintf(f,"+%s",regnames[p->reg]);
  278.       else
  279.     fprintf(f,"+%ld(FP)", zl2l(p->v->offset));
  280.     }else{
  281.       if(p->v->storage_class==STATIC){
  282.     fprintf(f,"+L%ld",zl2l(p->v->offset));
  283.       }else{
  284.     fprintf(f,"+_%s",p->v->identifier);
  285.       }
  286.     }
  287.     fprintf(f,"(%s)",p->v->identifier);
  288.     if(p->v->reg) fprintf(f,":%s",regnames[p->v->reg]);
  289.   }
  290.   if((p->flags®)&&!(p->flags&VAR)) fprintf(f,"%s",regnames[p->reg]);
  291.   if(p->flags&KONST){
  292.     fprintf(f,"#");printval(f,&p->val,t&NU,1);
  293.   }
  294.   if(p->flags&DREFOBJ) fprintf(f,")");
  295. }
  296. void prl(FILE *o,struct struct_declaration *p)
  297. /* Gibt eine struct_declaration auf dem Bildschirm aus. */
  298. {
  299.   int i;
  300.   for(i=0;i<p->count;i++) {fprintf(o," %d.:",i); prd(o,(*p->sl)[i].styp);}
  301. }
  302. void prd(FILE *o,struct Typ *p)
  303. /* Gibt einen Typ auf dem Bildschirm aus.    */
  304. {
  305.   int f;
  306.   if(!p) {fprintf(o,"empty type ");return;}
  307.   f=p->flags;
  308. /*    fprintf(o,"(Sizeof=%ld,flags=%d)",zl2l(szof(p)),f);*/
  309. /*    if(type_uncomplete(p)) {fprintf(o,"incomplete ");}*/
  310.   if(f&CONST) {fprintf(o,"const ");f&=~CONST;}
  311.   if(f&STRINGCONST) {fprintf(o,"string-const ");f&=~STRINGCONST;}
  312.   if(f&VOLATILE) {fprintf(o,"volatile ");f&=~VOLATILE;}
  313.   if(f&UNSIGNED) {fprintf(o,"unsigned ");f&=~UNSIGNED;}
  314.   if(f==FUNKT){
  315.     fprintf(o,"function with parameters (");
  316.     prl(o,p->exact);
  317.     fprintf(o,") returning ");prd(o,p->next);return;
  318.   }
  319.   if(f==STRUCT){
  320.     fprintf(o,"struct with components {");
  321.     prl(o,p->exact);fprintf(o,"} ");
  322.     return;
  323.   }
  324.   if(f==UNION){
  325.     fprintf(o,"union with components {");
  326.     prl(o,p->exact);fprintf(o,"} ");
  327.     return;
  328.   }
  329.   if(f==POINTER) {fprintf(o,"pointer to ");prd(o,p->next);return;}
  330.   if(f==ARRAY) {fprintf(o,"array [size %ld] of ",zl2l(p->size));prd(o,p->next);return;}
  331.   fprintf(o,"%s",typname[f]);
  332. }
  333.  
  334. void insert_const2(union atyps *p,int t)
  335. /*  Traegt Konstante in entprechendes Feld ein.       */
  336. {
  337.   if(!p) ierror(0);
  338.   t&=NU;
  339.   if(t==CHAR) {p->vchar=vchar;return;}
  340.   if(t==SHORT) {p->vshort=vshort;return;}
  341.   if(t==INT) {p->vint=vint;return;}
  342.   if(t==LONG) {p->vlong=vlong;return;}
  343.   if(t==(UNSIGNED|CHAR)) {p->vuchar=vuchar;return;}
  344.   if(t==(UNSIGNED|SHORT)) {p->vushort=vushort;return;}
  345.   if(t==(UNSIGNED|INT)) {p->vuint=vuint;return;}
  346.   if(t==(UNSIGNED|LONG)) {p->vulong=vulong;return;}
  347.   if(t==FLOAT) {p->vfloat=vfloat;return;}
  348.   if(t==DOUBLE) {p->vdouble=vdouble;return;}
  349.   if(t==POINTER) {p->vpointer=vpointer;return;}
  350. }
  351. void eval_const(union atyps *p,int t)
  352. /*  Weist bestimmten globalen Variablen Wert einer CEXPR zu.       */
  353. {
  354.   int f=t&NQ;
  355.   if(!p) ierror(0);
  356.   if(f>=CHAR&&f<=LONG){
  357.     if(!(t&UNSIGNED)){
  358.       if(f==CHAR) vlong=zc2zl(p->vchar);
  359.       if(f==SHORT)vlong=zs2zl(p->vshort);
  360.       if(f==INT)  vlong=zi2zl(p->vint);
  361.       if(f==LONG) vlong=p->vlong;
  362.       vulong=zl2zul(vlong);
  363.       vdouble=zl2zd(vlong);
  364.     }else{
  365.       if(f==CHAR) vulong=zuc2zul(p->vuchar);
  366.       if(f==SHORT)vulong=zus2zul(p->vushort);
  367.       if(f==INT)  vulong=zui2zul(p->vuint);
  368.       if(f==LONG) vulong=p->vulong;
  369.       vlong=zul2zl(vulong);
  370.       vdouble=zul2zd(vulong);
  371.     }
  372.     vpointer=zul2zp(vulong);
  373.   }else{
  374.     if(f==POINTER){
  375.       vulong=zp2zul(p->vpointer);
  376.       vlong=zul2zl(vulong);vdouble=zul2zd(vulong);
  377.     }else{
  378.       if(f==FLOAT) vdouble=zf2zd(p->vfloat); else vdouble=p->vdouble;
  379.       vlong=zd2zl(vdouble);
  380.       vulong=zl2zul(vlong);
  381.     }
  382.   }
  383.   vfloat=zd2zf(vdouble);
  384.   vuchar=zul2zuc(vulong);
  385.   vushort=zul2zus(vulong);
  386.   vuint=zul2zui(vulong);
  387.   vchar=zl2zc(vlong);
  388.   vshort=zl2zs(vlong);
  389.   vint=zl2zi(vlong);
  390. }
  391.  
  392. struct function_info *new_fi(void)
  393. /*  Belegt neue function_info-Struktur und initialisiert sie.  */
  394. {
  395.   struct function_info *new;
  396.   new=mymalloc(sizeof(*new));
  397.   new->first_ic=new->last_ic=0;
  398.   new->vars=0;
  399.   new->inline_asm=0;
  400.   new->translation_unit=0;
  401.   new->used=new->modified=new->calls=0;
  402.   return new;
  403. }
  404. void free_fi(struct function_info *p)
  405. /*  Gibt ein function_info mit Inhalt frei.                     */
  406. {
  407.   if(p->first_ic) free_IC(p->first_ic);
  408.   if(p->vars) free_var(p->vars);
  409.   free(p->calls);
  410.   free(p->used);
  411.   free(p->modified);
  412.   free(p->inline_asm);
  413.   free(p);
  414. }
  415.  
  416.  
  417.