![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to simpl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront|
Return to simpl.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 root 1: /*ident "@(#)ctrans:src/simpl.c 1.5.4.25" */
2: /******************************************************************
3:
4: C++ source for cfront, the C++ compiler front-end
5: written in the computer science research center of Bell Labs
6:
7: Copyright (c) 1984 AT&T, Inc. All rigths Reserved
8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC.
9:
10: simpl.c:
11:
12: simplify the typechecked function
13: remove: classes:
14: class fct-calls
15: operators
16: value constructors and destructors
17: new and delete operators (replace with function calls)
18: initializers (turn them into statements)
19: constant expressions (evaluate them)
20: inline functions (expand the calls)
21: enums (make const ints)
22: unreachable code (delete it)
23: make implicit coersions explicit
24:
25: in general you cannot simplify something twice
26:
27: *******************************************************************/
28:
29: #include "cfront.h"
30:
31: Pname new_fct;
32: Pname del_fct;
33: Pname vec_new_fct;
34: Pname vec_del_fct;
35:
36: Pstmt del_list;
37: Pstmt break_del_list;
38: Pstmt continue_del_list;
39:
40: //bit not_inl; // is the current function an inline?
41: Pname curr_fct; // current function
42: Pexpr init_list;
43: Pexpr one;
44:
45: Ptype Pfct_type;
46: Ptype Pvptr_type;
47: Pbase mptr_type;
48: Ptype size_t_type;
49:
50: Pexpr cdvec(Pname f, Pexpr vec, Pclass cl, Pname cd, int,Pexpr);
51: Pstmt trim_tail(Pstmt tt);
52: Pname find_vptr(Pclass);
53: char *get_classname(char*);
54: char *drop_classname(char*);
55: loc no_where; // 0,0
56:
57: int imeasure; // a counter trying to measure the complexity of a function
58: // body to try to avoid expanding ``monster'' inlines.
59:
60: extern Pexpr initialize_vptrs (Pclass cl, Pexpr this_expr);
61:
62: /* Constructs an expression which initializes the given class's vptrs.
63: The this_expr forms the first part of the path expression for each
64: vptr assignment. The vptr assignments are combined into a comma
65: expression. */
66:
67:
68: static Pclass topclass;
69:
70: void simpl_init()
71: {
72: char* ns = oper_name(NEW);
73: char* ds = oper_name(DELETE);
74:
75: size_t_type = Pvoid_type->tsizeof()>uint_type->tsizeof()?ulong_type:uint_type;
76:
77: Pname nw = new name(ns);
78: nw->n_oper = NEW;
79: Pname a = new name;
80: a->tp = size_t_type;
81: nw->tp = new fct(Pvoid_type,a,1);
82: new_fct = nw->dcl(gtbl,EXTERN); // void* operator new(long);
83: delete nw;
84: // new_fct->use();
85:
86: Pname dl = new name(ds);
87: dl->n_oper = DELETE;
88: a = new name;
89: a->tp = Pvoid_type;
90: dl->tp = new fct(void_type,a,1);
91: del_fct = dl->dcl(gtbl,EXTERN);
92: delete dl;
93: // del_fct->use();
94:
95:
96: Pname vn = new name("__vec_new");
97: Pname vd = new name("__vec_delete");
98:
99: a = new name;
100: a->tp = Pvoid_type;
101: Pname al = a;
102: a = new name;
103: a->tp = int_type;
104: a->n_list = al;
105: al = a;
106: a = new name;
107: a->tp = int_type;
108: a->n_list = al;
109: al = a;
110: a = new name;
111: a->tp = Pvoid_type;
112: a->n_list = al;
113: al = a; /* (Pvoid, int, int, Pvoid) */
114:
115: vec_new_fct = gtbl->insert(vn,0);
116: delete vn;
117: vec_new_fct->tp = new fct(Pvoid_type,al,1);
118: vec_new_fct->n_scope = EXTERN;
119: PERM(vec_new_fct);
120: PERM(vec_new_fct->tp);
121: vec_new_fct->use();
122:
123: vec_new_fct->dcl_print(0);
124:
125: a = new name;
126: a->tp = int_type;
127: al = a;
128: a = new name;
129: a->tp = int_type;
130: a->n_list = al;
131: al = a;
132: a = new name;
133: a->tp = Pvoid_type;
134: a->n_list = al;
135: al = a;
136: a = new name;
137: a->tp = int_type;
138: a->n_list = al;
139: al = a;
140: a = new name;
141: a->tp = int_type;
142: a->n_list = al;
143: al = a;
144: a = new name;
145: a->tp = Pvoid_type;
146: a->n_list = al;
147: al = a; /* (Pvoid, int, int, Pvoid, int, int) */
148:
149: vec_del_fct = gtbl->insert(vd,0);
150: delete vd;
151: vec_del_fct->tp = new fct(void_type,al,1);
152: vec_del_fct->n_scope = EXTERN;
153: PERM(vec_del_fct);
154: PERM(vec_del_fct->tp);
155: vec_del_fct->use();
156:
157: vec_del_fct->dcl_print(0);
158:
159: one = new ival(1);
160: one->tp = int_type;
161: PERM(one);
162:
163: Pfct_type = new fct(int_type,0,1); // int (*)()
164: Pfct_type = Pfct_type->addrof();
165: PERM(Pfct_type);
166:
167: putstring("typedef int (*__vptp)();\n");
168: putstring("struct __mptr {short d; short i; __vptp f; };\n");
169:
170: Pname b = new name("__mptr");
171: b->tp = new classdef(STRUCT);
172: b->tp->defined = 1;
173: Pclass(b->tp)->obj_size = 8;
174: mptr_type = new basetype(COBJ,b);
175: PERM(mptr_type);
176:
177: Pvptr_type = mptr_type->addrof();
178: PERM(Pvptr_type);
179: }
180:
181: Ptable scope; /* current scope for simpl() */
182: Pname expand_fn; /* name of function being expanded or 0 */
183: Ptable expand_tbl; /* scope for inline function variables */
184:
185: Pname classdef::has_oper(TOK op)
186: {
187: Pexpr n = find_name(oper_name(op),0);
188: if (n == 0) return 0;
189:
190: while (n->base==REF || n->base==MDOT) {
191: Pexpr e = Pexpr(n);
192: n = Pname(n->mem);
193: delete e;
194: }
195: if (n->tp->base==FCT && Pname(n)->n_dcl_printed==0) Pname(n)->dcl_print(0);
196: return Pname(n);
197: }
198:
199: int is_expr(Pstmt s)
200: /*
201: is this statement simple enough to be converted into an expression for
202: inline expansion?
203: */
204: {
205: int i = 0;
206: if (s->base == BLOCK) {
207: if (s->s == 0) return 1;
208: s = s->s;
209: }
210: for (Pstmt ss = s; ss; ss = ss->s_list) {
211: //error('d',"ss %k",ss->base);
212: switch (ss->base) {
213: case BLOCK:
214: if (Pblock(ss)->memtbl || is_expr(ss->s)==0) return 0;
215: case SM:
216: if (ss->e && ss->e->base==ICALL) {
217: Pname fn = ss->e->il->fct_name;
218: Pfct f = Pfct(fn->tp);
219: if (f->f_expr == 0) return 0;
220: }
221: break;
222: case IF:
223: if (is_expr(ss->s)==0) return 0;
224: if (ss->else_stmt && is_expr(ss->else_stmt)==0) return 0;
225: break;
226: default:
227: return 0;
228: }
229: i++;
230: }
231: return i;
232: }
233:
234: int no_of_returns;
235:
236: void name::simpl()
237: {
238: //error('d',"name::simpl%n %d %k",this,tp->base,tp->base);
239: if (base == PUBLIC) return;
240:
241: if (tp == 0) error('i',"%n->N::simple(tp==0)",this);
242:
243: switch (tp->base) {
244: case 0:
245: error('i',"%n->N::simpl(tp->B==0)",this);
246:
247: case OVERLOAD:
248: { for (Plist gl = Pgen(tp)->fct_list; gl; gl=gl->l) gl->f->simpl();
249: break;
250: }
251:
252: case FCT:
253: { Pfct f = Pfct(tp);
254: Pname n;
255: Pname th = f->f_this;
256:
257: if (th) {
258: // Make "this" a register if it is used more than twice:
259: if (th->n_addr_taken) error("&this");
260: th->n_stclass = (2 < th->n_used) ? REGISTER : AUTO;
261: if (warning_opt
262: && th->n_assigned_to
263: && th->n_assigned_to!=FUDGE111)
264: error('w',&where,"assignment to this");
265: }
266:
267:
268: if (ansi_opt && f->body==0) {
269: // make sure arguments can be printed for decls
270:
271: for (Pname n = f->f_args; n; n = n->n_list) {
272: n->n_scope = ARG;
273: if (n->string) {
274: char* ps = new char[strlen(n->string)+1];
275: strcpy(ps,n->string);
276: n->string = ps;
277: }
278: /*
279: if (n_oper==DTOR && n->n_list==0) {
280: // add __free argument
281: Pname fa=new name;
282: fa->tp = int_type;
283: n->n_scope = ARG;
284: // ps = new char[6];
285: // strcpy(ps, "__free");
286: // fa->string = ps;
287: n->n_list = fa;
288: break;
289: }
290: */
291: }
292: }
293:
294: if (tp->defined & (SIMPLIFIED | ~DEFINED) ) return;
295:
296: for (n=f->f_args; n; n=n->n_list) n->simpl();
297:
298: if (f->body) {
299: Ptable oscope = scope;
300: Pname ocurr = curr_fct;
301: int oim = imeasure;
302: scope = f->body->memtbl;
303: //error('d',"body");
304: if (scope == 0) error('i',"%n memtbl missing",this);
305: curr_fct = this;
306: f->simpl();
307: if (f->f_inline==0 || debug_opt)
308: f->f_imeasure = 0; // not a converted inline
309: else {
310: // first check if the function is too large to
311: // be worth inlining
312: if (12<f->f_imeasure) { // cut-over point:
313: // about 12 assignments
314: // f->f_imeasure indicates
315: f->f_inline = 0;// a converted inline
316: //error('d',"don't inline%n %d %d %d",this,this,f,f->f_imeasure);
317: tp->defined |= SIMPLIFIED;
318: return;
319: }
320: int i = 0;
321: for (n=f->f_args; n; n=n->n_list) {
322: n->base = ANAME;
323: n->n_val = i++;
324: // ?? if (n->n_table != scope) error('i',"aname scope: %d %n %d %d\n",n,n,n->n_table,scope);
325: }
326: expand_tbl = (f->returns->base!=VOID || n_oper==CTOR) ? scope : 0;
327: expand_fn = this;
328:
329: if (expand_tbl) {
330: genlab:
331: // value returning: generate expr
332: // the body still holds the memtbl
333: Pexpr ee = Pexpr(f->body->expand());
334: Ptype t = 0;
335: if (f->s_returns) {
336: if (ee->tp!=f->s_returns) t = f->s_returns;
337: }
338: else if (ee->tp!=f->returns)
339: t = f->returns;
340: // VCVC assumes VOID is output as CHAR:
341: /* But this is not needed on a sun, and just makes the debugger print trash */
342: #ifndef sun
343: if (t && t==void_type && ansi_opt == 0)
344: ee = new expr(CM,ee,new cast(char_type,zero));
345: #endif
346: f->f_expr = (ee->base==CM) ? ee : new expr(CM,zero,ee);
347: // print.c assumes expansion into comma expression
348: }
349: else {
350: if (is_expr(f->body)) {
351: // can generate expr: do
352: expand_tbl = scope;
353: goto genlab;
354: }
355: // not value return: can generate block
356: f->f_expr = 0;
357: f->body = Pblock(f->body->expand());
358: }
359: expand_fn = 0;
360: expand_tbl = 0;
361: }
362: scope = oscope;
363: curr_fct = ocurr;
364: imeasure = oim;
365: }
366: break;
367: }
368:
369: case CLASS:
370: Pclass(tp)->simpl();
371: }
372:
373: if (n_initializer) n_initializer->simpl();
374: tp->defined |= SIMPLIFIED;
375: }
376:
377: Pexpr call_ctor(Ptable tbl, Pexpr p, Pexpr ctor, Pexpr args, int d, Pexpr vb_args)
378: {
379: Pexpr ee = new ref(d,p,ctor);
380: if (p==0 || tbl==0) ee->tp = ctor->tp;
381: //error('d',"call_ctor(tbl %d, p %d, %n, args %d)",tbl,p,ctor,args);
382: if (args && args->base!=ELIST) args = new expr(ELIST,args,0);
383: ee = new expr(G_CALL,ee,args);
384: Pname n = Pname(ctor);
385: while (n->base == MDOT) n = Pname(n->mem);
386: if (n->tp->base == FCT) ee->fct_name = n;
387: if (tbl)
388: ee = ee->typ(tbl);
389: else if (n->tp->base == FCT)
390: ee->tp = Pfct(n->tp)->s_returns;
391: if (ee->tp == any_type) return ee;
392: args = ee->e2;
393:
394: if (vb_args == 0) { // attach zero vbase arguments
395: Pfct f = Pfct(ee->fct_name->tp); // not n->fct_name
396: for (Pname nn = f->f_args->n_list; nn && nn!=f->argtype; nn=nn->n_list)
397: args = new expr(ELIST,zero,args);
398: }
399: else { // attach vbase arguments
400: if (args) {
401: for (Pexpr d = vb_args; d->e2; d=d->e2);
402: d->e2 = args;
403: }
404: args = vb_args;
405: }
406:
407: ee->e2 = args;
408: return ee;
409: }
410:
411: Pexpr call_dtor(Pexpr p, Pexpr dtor, Pexpr arg, int d, Pexpr vb_args)
412: {
413: // error('d',"call dtor %k %n %t vb_args %d",d,dtor,dtor->tp,vb_args);
414: Pexpr r = new ref(d,p,dtor);
415:
416: if (arg && vb_args) {
417: arg = new ival(3);
418: arg->tp = int_type;
419: }
420: else if (vb_args) {
421: arg = new ival(2);
422: arg->tp = int_type;
423: }
424: else if (arg==0)
425: arg = zero;
426:
427: Pexpr aa = new expr(ELIST,arg,0); // argument controlling deallocation
428: // 2: destroy vbases
429: // 1: dealllocate, 0: don't
430:
431: Pfct f = Pfct(dtor->tp); // attach virtual base arguments
432: // for (Pname nn = f->f_args->n_list; nn && nn->n_list; nn=nn->n_list) {
433: // Pexpr xx = vb_args ? new cast(nn->tp,one) : zero;
434: // aa = new expr(ELIST,xx,aa);
435: // }
436:
437:
438: Pexpr ee = new call(r,aa);
439: while (dtor->base == MDOT) dtor = dtor->mem;
440: if (d == REF) // could be virtual
441: ee->fct_name = Pname(dtor);
442: else { // virtual suppressed, store fct name
443: r->n_initializer = dtor;
444: ee->fct_name = 0;
445: }
446: ee->base = G_CALL;
447: ee->tp = void_type;
448:
449: if (f->memof->c_body == 1) f->memof->dcl_print(0);
450: if (Pname(dtor)->n_dcl_printed==0) Pname(dtor)->dcl_print(0);
451:
452: return ee;
453: }
454:
455: //extern int new_used; // pre-define new and delete only if the user didn't
456:
457: Pstmt fct::dtor_simpl(Pclass cl, Pexpr th)
458: {
459: Pstmt dtail = 0;
460: //error('d',"simpl_dtor(%t) a %d",cl,f_args);
461: // if (new_used == 0) new_init();
462:
463: Pname fa = new name("__free"); // fake argument for dtor
464: fa->tp = int_type;
465: Pname free_arg = fa->dcl(body->memtbl,ARG);
466: free_arg->where = no_where;
467: delete fa;
468: Pname a = f_args;
469: if (a==0 || a->n_list==0) error('i',"__freeA missing in destructor for %t",cl);
470: Pname p = 0;
471: for(;;p=a,a=a->n_list) { // replace nameless fake argument
472: //error('d',"a %d %t",a,a->tp);
473: if (a->n_list == 0) {
474: // a->n_list = free_arg;
475: DEL(p->n_list);
476: p->n_list = free_arg;
477: break;
478: }
479: }
480:
481: // generate calls to destructors for all members of class cl:
482: Ptable tbl = cl->memtbl;
483: int i = 1;
484: for (Pname m=tbl->get_mem(i); m; m=tbl->get_mem(++i) ) {
485:
486: if (m->n_stclass == STATIC) continue;
487:
488: Ptype t = m->tp;
489: Pexpr ee = 0;
490: Pname cn;
491: Pname dtor;
492:
493: if (cn = t->is_cl_obj()) {
494: Pclass cl = (Pclass)cn->tp;
495: if (dtor = cl->has_dtor()) { // dtor(this,0,ones);
496: ee = new ref(REF,th,m);
497: ee->tp = m->tp;
498: ee = call_dtor(ee,dtor,0,DOT,one);
499: check_visibility(dtor,0,Pclass(dtor->n_table->t_name->tp),tbl,curr_fct);
500: }
501: }
502: else if (cl_obj_vec) {
503: Pclass cl = Pclass(cl_obj_vec->tp);
504: if (dtor = cl->has_dtor()) {
505: Pfct f = Pfct(dtor->tp);
506: int i = 0;
507: for (Pname nn = f->f_args->n_list; nn && nn->n_list; nn=nn->n_list) i++;
508: //error('d',"dtor %n i %d",dtor,i);
509: ee = new ref(REF,th,m);
510: ee->tp = m->tp;
511: ee = cdvec(vec_del_fct,ee,cl,dtor,0,new ival(i));
512: check_visibility(dtor,0,Pclass(dtor->n_table->t_name->tp),tbl,curr_fct);
513: }
514: }
515:
516: if (ee) {
517: Pstmt es = new estmt(SM,curloc,ee,0);
518: // reverse order of destructors for members
519: es->s_list = del_list;
520: del_list = es;
521: if (dtail == 0) dtail = es;
522: }
523: }
524:
525:
526: Pexpr ee = 0;
527: // look for bases with destructors:
528: // generate: dtor(base,0);
529:
530: Pbcl b = 0; // get dtors in order with virtual bases last
531: Pbcl t = 0;
532: for (Pbcl l = cl->baselist; l; l=l->next) {
533: if (l->base != VIRTUAL) {
534: Pbcl x = new basecl(l->bclass,0);
535: if (t == 0)
536: b = x;
537: else
538: t->next = x;
539: t = x;
540: x->base = l->base;
541: x->obj_offset = l->obj_offset;
542: }
543: }
544: for (l = cl->baselist; l; l=l->next) {
545: if (l->base == VIRTUAL) {
546: b = new basecl(l->bclass,b);
547: b->base = l->base;
548: b->obj_offset = l->obj_offset;
549: }
550: }
551: Pexpr ve = 0;
552:
553: for (; b; b=l) {
554: Pclass bcl = b->bclass;
555: l = b->next;
556: Pname dtor = bcl->has_dtor();
557:
558: if (dtor) {
559: Pexpr val = rptr(bcl->this_type,th,b->obj_offset);
560: val = val->contents();
561: Pexpr e = call_dtor(val,dtor);
562: if (b->base == VIRTUAL) {
563: // if (x) this->x.dtor(); where x is a vbase
564: for (Pname dd = f_this->n_list; dd!=argtype; dd=dd->n_list)
565: if (strcmp(dd->string,bcl->string)==0) break;
566:
567: #ifndef sun
568: if (ansi_opt) { // q?void:int would be an error
569: #endif
570: e = new expr(G_CM,e,zero);
571: e->tp = zero_type;
572: #ifndef sun
573: }
574: #endif
575: e = new expr(QUEST,e,zero);
576: Pexpr two = new ival(2);
577: two->tp = int_type;
578: e->cond = new expr (AND,free_arg,two);//dd;
579: }
580: ee = ee ? new expr(CM,e,ee) : e;
581: }
582: delete b;
583: }
584:
585: Pstmt es = ee ? new estmt(SM,curloc,ee,0) : 0;
586:
587: ee = new expr(ELIST,th,0); // free storage
588: Pname n = new name(oper_name(DELETE));
589: Pexpr del = find_name(n,cl,scope,CALL,curr_fct);
590: if (del->tp->base==OVERLOAD || Pfct(del->tp)->nargs==2) {
591: Pexpr ss = new texpr(SIZEOF,cl,0);
592: ss->tp = uint_type;
593: ee->e2 = new expr(ELIST,ss,0);
594: }
595: ee = new call(del,ee);
596: ee->tp = ee->call_fct(scope);
597:
598: Pstmt ess = new estmt(SM,curloc,ee,0);
599: ess = new ifstmt(curloc,new expr(AND,free_arg,one),ess,0);
600: if (es)
601: es->s_list = ess;
602: else
603: es = ess;
604:
605: free_arg->use();
606: Pname(th)->use();
607:
608: if (dtail)
609: dtail->s_list = es;
610: else
611: del_list = es;
612:
613: del_list = new ifstmt(curloc,th,del_list,0);
614: if (del_list) del_list->simpl();
615: return dtail;
616: }
617:
618:
619: Pclass find_vbase_ptr(Pclass cl, Pclass vbase)
620: {
621: for (Pbcl bb = cl->baselist; bb; bb = bb->next) {
622: if (bb->bclass==vbase && bb->ptr_offset) return cl;
623: Pclass f = find_vbase_ptr(bb->bclass,vbase);
624: if (f) return f;
625: }
626: return 0;
627: }
628:
629: Pclass second_base(Pclass cl, Pclass base)
630: {
631: //error('d',"second_base(%t,%t)",cl,base);
632: for (Pbcl b = cl->baselist; b && b->base==NAME; b = b->next) {
633: if (b->bclass==base) {
634: if (b==cl->baselist) return 0;
635: return base;
636: }
637: Pclass bb = second_base(b->bclass,base);
638: if (bb == Pclass(-1)) continue; // not found
639: if (bb) {
640: if (b!=cl->baselist) error('s',"C hierarchy too complicated");
641: return bb; // second base of b->bclass
642: }
643: if (b==cl->baselist) return 0;
644: return b->bclass; // b->bclass is second base
645: }
646: return Pclass(-1);
647: }
648:
649: //Pclass topclass;
650:
651: Pexpr classdef::get_vptr_exp(char *s)
652: {
653: //error('d',"%t::get_vptr_exp(%s)",this,s?s:"0");
654: if (c_body == 1) dcl_print(0);
655: if (c_body == 3) print_all_vtbls(this);
656: if (s == 0) return find_vptr(this);
657: Pbcl b = get_base(get_classname(s));
658: Pexpr vp = b->bclass->get_vptr_exp(drop_classname(s));
659: if (b==baselist && b->base!=VIRTUAL) return vp;
660: vp = new mdot(b->bclass->string,vp);
661: if (c_body == 1) b->bclass->dcl_print(0);
662: if (c_body == 3) b->bclass->print_all_vtbls(b->bclass);
663: if (b->base == VIRTUAL) {
664: vp->i1 = 1;
665: if (b->ptr_offset == 0) { // pointer to base in intermediate base
666: Pclass bb = find_vbase_ptr(this,b->bclass);
667: Pclass sb = second_base(topclass,bb);
668: //error('d',"mdot %t %t : %d %t ",topclass,bb,sb,sb==Pclass(-1)?0:sb);
669: if (sb && sb!=Pclass(-1)) vp = new mdot(sb->string,vp);
670: }
671: }
672: return vp;
673: }
674:
675: int fct::ctor_simpl(Pclass cl, Pexpr th)
676: {
677: Ptable tbl = cl->memtbl;
678:
679: int ass_count = 0;
680: init_list = 0;
681: //error('d',"ctor_simpl %t: %t",cl,this);
682: /*
683: initialization order:
684: (1) virtual base pointers and virtual bases
685: (they may be used in non-virtual bases)
686: (2) non-virtual bases
687: (3) virtual function pointers
688: (4) members
689: */
690:
691: // initialize virtual base pointers and virtual base objects
692: for (Pbcl l = cl->baselist; l; l=l->next) {
693: Pexpr i = l->init;
694: if (l->base != VIRTUAL) continue;
695: l->init = 0;
696: //error('d',"simpl virtual base %t i %d ",l->bclass,i);
697:
698: // assign virtual OP to virtual base AP
699: Pclass bc = l->bclass;
700: Pexpr dp = 0;
701:
702: // dd = pointer argument for this base;
703: // non-zero if already initialized
704: for (Pname dd = f_this->n_list; dd!=argtype; dd=dd->n_list)
705: if (strcmp(dd->string,bc->string)==0) break;
706:
707: // initialize virtual base object
708: //error('d',"bc %t dd %n offset %d init %d",bc,dd,l->obj_offset,l->init);
709: // => bc_arg = (bc*)((char*)this+offset)
710: int off = l->obj_offset;
711: Pexpr val = rptr(bc->this_type,th,off);
712: dp = new expr(ASSIGN,dd,val);
713: dd->assign();
714:
715: // => bc::bc()
716: if (i) {
717: switch (i->base) {
718: case ASSIGN:
719: case CM:
720: break;
721: case CALL:
722: case G_CALL:
723: { Pcall cc = Pcall(i);
724: Pname bn = cc->fct_name;
725: ass_count = Pfct(bn->tp)->f_this->n_assigned_to;
726: cc->simpl();
727: break;
728: }
729: default:
730: error('i',"badBCIr %k",i->base);
731: }
732: dp = new expr(CM,dp,i);
733: }
734:
735: // => (bc_arg==0)?dp:bc_arg
736: for (Pname a = f_args->n_list; a; a = a->n_list)
737: if (strcmp(bc->string,a->string)==0) {
738: dp = new expr(QUEST,dp,a);
739: dp->cond = new expr(EQ,a,zero);
740: break;
741: }
742:
743: // Pname dpp = find_vbase_ptr(bc,cl);
744: for (Pbcl ll=cl->baselist; ll; ll=ll->next) {
745: if (ll->bclass==bc && ll->ptr_offset) {
746: // make sure that the delegate_arg is needed
747: // here and not just in a base
748:
749: // this->Pd = (bc_arg==0)?dp:bc_arg
750: Pexpr dpp = new mdot(bc->string,th);
751: dpp->i1 = 3;
752: dp = new expr(ASSIGN,dpp,dp);
753: //error('d',"dpp %n",dpp);
754: break;
755: }
756: }
757:
758: // reverse init order
759: if (dp) init_list = init_list ? new expr(CM,dp,init_list) : dp;
760: }
761:
762: // generate: this=base::base(args) (non-virtual bases)
763: {
764: for (Pbcl l = cl->baselist; l; l=l->next) {
765: Pexpr i = l->init;
766: if (i==0 || l->base==VIRTUAL) continue;
767: //error('d',"simpl base %t i %d ",l->bclass,i);
768: l->init = 0;
769:
770: switch (i->base) {
771: case ASSIGN:
772: case CM:
773: break;
774: case CALL:
775: case G_CALL:
776: { Pcall cc = Pcall(i);
777: Pname bn = cc->fct_name;
778: ass_count = Pfct(bn->tp)->f_this->n_assigned_to;
779: cc->simpl();
780: // assign to ``this'' only from only base
781: if (l==cl->baselist && cl->baselist->next==0) i = new expr(ASSIGN,th,cc);
782: break;
783: }
784: default:
785: error('i',"badBCIr %k",i->base);
786: }
787:
788: init_list = init_list ? new expr(G_CM,init_list,i) : i;
789: }
790: }
791:
792: // initialize the vptrs that are updated by this class
793:
794: if (th) {
795: Pexpr ee = initialize_vptrs (cl, th);
796: if (ee)
797: init_list = init_list ? new expr(CM,init_list,ee) : ee;
798: }
799:
800: else {
801: error('i', "%t->fct::ctor_simpl(): th found to be null", cl);
802: }
803:
804:
805: // initialize members in declaration order:
806: int i;
807: for (Pname m=tbl->get_mem(i=1); m; m=tbl->get_mem(++i) ) {
808: Ptype t = m->tp;
809: Pname cn;
810: Pname ctor;
811: if (t == 0) continue;
812:
813: switch (t->base) {
814: case FCT:
815: case OVERLOAD:
816: case CLASS:
817: case ENUM:
818: continue;
819: }
820:
821: switch (m->n_stclass) {
822: case STATIC:
823: case ENUM:
824: continue;
825: }
826:
827: if (m->base == PUBLIC) continue;
828:
829: Pexpr ee = m->n_initializer;
830: if (ee) m->n_initializer = 0; // from fct must not persist until next fct
831: //error('d',"simpl m %n ee %d",m,ee);
832: if (ee) {
833: // init of non-class mem
834: // set in fct::mem_init()
835: }
836: else if (cn=t->is_cl_obj()) { // try for default
837: Pclass cl = Pclass(cn->tp);
838: if (ctor = cl->has_ictor()) {
839: Pexpr r = new ref(REF,th,m);
840: ee = call_ctor(tbl,r,ctor,0,DOT);
841: check_visibility(ctor,0,Pclass(ctor->n_table->t_name->tp),tbl,curr_fct);
842: }
843: else if (cl->has_ctor()) {
844: error("M%n needsIr (no defaultK forC %s)",m,cl->string);
845: }
846: }
847: else if (cl_obj_vec) {
848: Pclass cl = Pclass(cl_obj_vec->tp);
849: if (ctor = cl->has_ictor()) { // _new_vec(vec,noe,sz,ctor);
850: Pexpr mm = new ref(REF,th,m);
851: mm->tp = m->tp;
852: ee = cdvec(vec_new_fct,mm,cl,ctor,-1,0);
853: check_visibility(ctor,0,Pclass(ctor->n_table->t_name->tp),tbl,curr_fct);
854: }
855: else if (cl->has_ctor()) {
856: error("M%n[] needsIr (no defaultK forC %s)",m,cl->string);
857: }
858: }
859: else if (t->is_ref()) {
860: error("RM%n needsIr",m);
861: }
862: else if (t->tconst() && vec_const==0) {
863: error("constM%n needsIr",m);
864: }
865:
866: if (ee) {
867: ee->simpl();
868: init_list = init_list ? new expr(CM,init_list,ee) : ee;
869: }
870: } // for m
871: //error('d',"ctor->");
872: return ass_count;
873: }
874:
875: void fct::simpl()
876: /*
877: call only for the function definition (body != 0)
878:
879: simplify argument initializers, and base class initializer, if any
880: then simplify the body, if any
881:
882: for constructor:call allocator if this==0 and this not assigned to
883: (auto and static objects call constructor with this!=0,
884: the new operator generates calls with this==0)
885: call base & member constructors
886: for destructor: call deallocator (no effect if this==0)
887: case base & member destructors
888:
889: for arguments and function return values look for class objects
890: that must be passed by constructor X(X&).
891:
892: Allocate temporaries for class object expressions, and see if
893: class object return values can be passed as pointers.
894:
895: call constructor and destructor for local class variables.
896: */
897: {
898: Pexpr th = f_this;
899: Ptable tbl = body->memtbl;
900: Pstmt ss = 0;
901: Pstmt tail;
902: Pclass cl = th ? Pclass(Pbase(Pptr(th->tp)->typ)->b_name->tp) : 0;
903: Pstmt dtail = 0;
904:
905: Pname ocurr_fct = curr_fct;
906: int oret = no_of_returns;
907: int oim = imeasure;
908:
909: //error('d',"fct::simpl %n %t",curr_fct,this);
910: // not_inl = f_inline==0;
911: del_list = 0;
912: continue_del_list = 0;
913: break_del_list = 0;
914: scope = tbl;
915: if (scope == 0) error('i',"F::simpl()");
916: int ass_count = 0;
917: imeasure = 0;
918: no_of_returns = 0;
919:
920: cc->stack();
921: cc->nof = curr_fct;
922: cc->ftbl = tbl;
923:
924: // modification for local classes defined within inline functions
925: extern Plist local_class;
926: // error( 'd', "simpl local_class: %d", local_class );
927: for ( Plist l = local_class; l; l = l->l ) {
928: Pname n = l->f;
929: Pclass cl = Pclass(Pbase(n->tp)->b_name->tp);
930: if ( cl->in_fct == 0 ) cl->in_fct = cc->nof;
931: if ( cl->lcl == 0 ) cl->lcl = make_name( 'L' );
932: if ( cl->c_body == 1 ) cl->dcl_print(0);
933: }
934:
935: Pfct(cc->nof->tp)->local_class = local_class;
936: local_class = 0;
937: // error( 'd', "simpl nof: %n %d local_class: %d", cc->nof, cc->nof, Pfct(cc->nof->tp)->local_class );
938:
939: switch (curr_fct->n_scope) {
940: case 0:
941: case PUBLIC:
942: cc->not = curr_fct->n_table->t_name;
943: cc->cot = Pclass(cc->not->tp);
944: cc->tot = cc->cot->this_type;
945: }
946:
947: switch (curr_fct->n_oper) {
948: case DTOR:
949: dtail = dtor_simpl(cl,th);
950: break;
951: case CTOR:
952: ass_count = ctor_simpl(cl,th);
953: }
954:
955: tail = body->simpl();
956:
957: if (returns->base!=VOID || f_result) { // return must have been seen
958: if (no_of_returns) { // could be OK
959: Pstmt tt = (tail->base==RETURN || tail->base==LABEL) ? tail : trim_tail(tail);
960:
961: switch (tt->base) {
962: case RETURN:
963: case GOTO:
964: del_list = 0; // no need for del_list
965: break;
966: case SM:
967: if (tt->e)
968: switch (tt->e->base) {
969: case ICALL:
970: case G_CALL:
971: goto chicken;
972: }
973: default:
974: if (warning_opt || strcmp(curr_fct->string,"main"))
975: error('w',"maybe no value returned from%n",curr_fct);
976: case IF:
977: case SWITCH:
978: case DO:
979: case WHILE:
980: case FOR:
981: case LABEL:
982: chicken: // don't dare write a warning
983: break;
984: }
985: }
986: else { // must be an error
987: // but we don't dare complain about main()
988: // if (strcmp(curr_fct->string,"main"))
989: // error(Pfct(curr_fct->tp)->returns->is_cl_obj()?0:'w',"no value returned from%n",curr_fct);
990: // else if (warning_opt)
991: // error('w',"no value returned from%n",curr_fct);
992: if (Pfct(curr_fct->tp)->f_inline
993: && Pfct(curr_fct->tp)->returns!=void_type
994: && Pfct(curr_fct->tp)->returns->is_cl_obj())
995: // can cause code generation errors if allowed
996: error("no value returned from%n",curr_fct);
997: else if (warning_opt || strcmp(curr_fct->string,"main"))
998: error('w',"no value returned from%n",curr_fct);
999: }
1000: if (del_list) goto zaq;
1001: }
1002: else if (del_list) { // return may not have been seen
1003: zaq:
1004: if (tail)
1005: tail->s_list = del_list;
1006: else
1007: body->s = del_list;
1008: tail = dtail;
1009: }
1010:
1011: if (curr_fct->n_oper == DTOR) { // body => if (this == 0) body
1012:
1013: // reset the vptrs that were set by this class
1014: for (Pvirt blist = cl->virt_list; blist; blist = blist->next) {
1015: //error('d',"vptr init %s in %s",blist->string,cl->string);
1016: topclass = cl;
1017: Pexpr vp = cl->get_vptr_exp(blist->string);
1018:
1019: extern char *make_local_name(Pclass, int=0);
1020: char *str = 0;
1021: if ( cl->lex_level ) str = make_local_name( cl );
1022: Pexpr vtbl = new text_expr(blist->string,str?str:cl->string);
1023:
1024: Pexpr ee = new ref(REF,th,vp);
1025: ee->tp = vp->tp;
1026: ee = new expr(ASSIGN,ee,vtbl);
1027: Pstmt es = new estmt(SM,curloc,ee,0);
1028: es->s_list = body->s;
1029: body->s = es;
1030: }
1031:
1032: body->s = new ifstmt(body->where,th,body->s,0);
1033: }
1034:
1035: if (curr_fct->n_oper == CTOR) {
1036:
1037: if (Pname(th)->n_assigned_to == 0) {
1038: /* generate:
1039: if (this || (this=_new( sizeof(class cl) ))) {
1040: init_list ;
1041: body;
1042: }
1043: */
1044: Pname(th)->n_assigned_to = ass_count ? ass_count : FUDGE111;
1045: Pexpr sz = new texpr(SIZEOF,cl,0);
1046: (void) cl->tsizeof();
1047: sz->tp = uint_type;
1048: Pexpr ee = new expr(ELIST,sz,0);
1049: Pname n = new name(oper_name(NEW));
1050: Pexpr p = find_name(n,cl,scope,CALL,curr_fct);
1051: //error('d',"in ctor %n call %n",curr_fct,p);
1052: ee = new call(p,ee);
1053: ee->tp = ee->call_fct(cl->memtbl);
1054: ee->simpl();
1055: ee = new expr(ASSIGN,th,ee);
1056: ee = new expr(OROR,th,ee);
1057: /*ifs->simpl();
1058: do not simplify
1059: or "this = " will cause an extra call of base::base
1060: */
1061: if (init_list) {
1062: Pstmt es = new estmt(SM,body->where,init_list,0);
1063: es->s_list = body->s;
1064: body->s = es;
1065: // if (tail == 0) tail = es;
1066: }
1067: else if (body->s == 0)
1068: body->s = new estmt(SM,body->where,0,0);
1069: ifstmt* ifs = new ifstmt(body->where,ee,body->s,0);
1070: body->s = ifs;
1071: // if (tail == 0)
1072: tail = ifs;
1073: }
1074: // generate: body; return this;
1075: Pstmt st = new estmt(RETURN,curloc,th,0);
1076: if (tail)
1077: tail->s_list = st;
1078: else
1079: body->s = st;
1080: tail = st;
1081: }
1082: f_imeasure = imeasure;
1083: curr_fct = ocurr_fct;
1084: no_of_returns = oret;
1085: imeasure = oim;
1086: cc->unstack();
1087: }
1088:
1089:
1090: void classdef::simpl()
1091: {
1092: int i;
1093: //error('d',"classdef::simpl %s %d",string,defined&SIMPLIFIED);
1094:
1095: if (defined&SIMPLIFIED) return;
1096:
1097: Pclass oc = in_class;
1098: in_class = this;
1099:
1100: for (Pname m=memtbl->get_mem(i=1); m; m=memtbl->get_mem(++i) ) {
1101: Pexpr i = m->n_initializer;
1102: m->n_initializer = 0;
1103: m->simpl();
1104: m->n_initializer = i;
1105: }
1106:
1107: in_class = oc;
1108:
1109: for (Plist fl=friend_list; fl; fl=fl->l) { // simplify friends
1110: Pname p = fl->f;
1111: switch (p->tp->base) {
1112: case FCT:
1113: case OVERLOAD:
1114: p->simpl();
1115: }
1116: }
1117:
1118: defined |= SIMPLIFIED;
1119: }
1120:
1121:
1122:
1123:
1124: Pexpr initialize_vptrs (Pclass cl, Pexpr this_expr)
1125:
1126: /* Constructs an expression which initializes the given class's vptrs.
1127: The this_expr forms the first part of the path expression for each
1128: vptr assignment. The vptr assignments are combined into a comma
1129: expression. */
1130:
1131: {
1132:
1133: Pexpr init_list = 0;
1134:
1135:
1136: /* initialize the vptrs that are updated by this class */
1137:
1138: for (Pvirt blist = cl->virt_list; blist; blist = blist->next) {
1139:
1140: topclass = cl;
1141: Pexpr vptr_exp = cl->get_vptr_exp(blist->string);
1142:
1143: extern char *make_local_name(Pclass, int=0);
1144: char *str = 0;
1145: if ( cl->lex_level ) str = make_local_name(cl);
1146: Pexpr vtbl = new text_expr(blist->string,str?str:cl->string);
1147:
1148: Pexpr ee;
1149: if (this_expr)
1150: ee = new ref(REF, this_expr, vptr_exp);
1151: else
1152: ee = vptr_exp;
1153:
1154: ee->tp = vptr_exp->tp;
1155: ee = new expr(ASSIGN, ee, vtbl);
1156: init_list = init_list ? new expr(CM, init_list, ee) : ee;
1157: }
1158:
1159: return init_list;
1160:
1161: } /* initialize_vptrs */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.