![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to simp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / lcc / c|
Return to simp.c CVS log | Up to [Research Unix] / researchv10no / cmd / lcc / c |
1.1 root 1: /* C compiler: tree simplification and constant folding */
2:
3: #include "c.h"
4:
5: int needconst; /* >=1 if parsing a constant expression */
6:
7: dclproto(static int add,(double, double, double, double, int));
8: dclproto(static Tree addrnode,(Symbol, int, Type));
9: dclproto(static int div,(double, double, double, double, int));
10: dclproto(static int mul,(double, double, double, double, int));
11: dclproto(static int sub,(double, double, double, double, int));
12:
13: /* add - return 1 if min <= x+y <= max, 0 otherwise */
14: static int add(x, y, min, max, needconst) double x, y, min, max; {
15: int cond = x == 0 || y == 0
16: || x < 0 && y < 0 && x >= min - y
17: || x < 0 && y > 0
18: || x > 0 && y < 0
19: || x > 0 && y > 0 && x <= max - y;
20: if (!cond && needconst) {
21: warning("overflow in constant expression\n");
22: cond = 1;
23: }
24: return cond;
25: }
26:
27: /* addrnode - create a tree for addressing expression p+n, type ty */
28: static Tree addrnode(p, n, ty) Symbol p; Type ty; {
29: Symbol q = (Symbol)talloc(sizeof *q);
30: Tree e;
31: static struct symbol z;
32:
33: *q = z;
34: q->name = stringd(genlabel(1));
35: q->sclass = p->sclass;
36: q->scope = p->scope;
37: q->type = ty;
38: q->defined = 1;
39: q->temporary = p->temporary;
40: q->generated = p->generated;
41: q->computed = 1;
42: q->addressed = p->addressed;
43: q->ref = 1;
44: if (p->scope == GLOBAL || p->sclass == STATIC || p->sclass == EXTERN) {
45: q->sclass = p->sclass == AUTO ? STATIC : p->sclass;
46: (*IR->address)(q, p, n);
47: e = tree(ADDRG+P, ty, 0, 0);
48: } else {
49: Code cp;
50: if (!p->defined)
51: addlocal(p);
52: cp = code(Address);
53: cp->u.addr.sym = q;
54: cp->u.addr.base = p;
55: cp->u.addr.offset = n;
56: e = tree(p->scope == PARAM ? ADDRF+P : ADDRL+P, ty, 0, 0);
57: }
58: e->u.sym = q;
59: return e;
60: }
61:
62: /* div - return 1 if min <= x/y <= max, 0 otherwise */
63: static int div(x, y, min, max, needconst) double x, y, min, max; {
64: int cond;
65:
66: if (x < 0) x = -x;
67: if (y < 0) y = -y;
68: cond = y != 0 && (y > 1 || x <= max*y);
69: if (!cond && y != 0 && needconst) {
70: warning("overflow in constant expression\n");
71: cond = 1;
72: }
73: return cond;
74: }
75:
76: /* ispow2 - if u > 1 && u == 2^n, return n, otherwise return 0 */
77: int ispow2(u) unsigned u; {
78: int n;
79:
80: if (u > 1 && (u&(u-1)) == 0)
81: for (n = 0; u; u >>= 1, n++)
82: if (u&1)
83: return n;
84: return 0;
85: }
86:
87: /* mul - return 1 if min <= x*y <= max, 0 otherwise */
88: static int mul(x, y, min, max, needconst) double x, y, min, max; {
89: int cond = x > -1 && x <= 1 || y > -1 && y <= 1
90: || x < 0 && y < 0 && -x <= max/-y
91: || x < 0 && y > 0 && x >= min/y
92: || x > 0 && y < 0 && x >= min/y
93: || x > 0 && y > 0 && x <= max/y;
94: if (!cond && needconst) {
95: warning("overflow in constant expression\n");
96: cond = 1;
97: }
98: return cond;
99: }
100:
101: #define xcvtcnst(FTYPE,TTYPE,EXP,VAR,MIN,MAX) \
102: if (l->op == CNST+FTYPE) { \
103: if (needconst && (VAR < MIN || VAR > MAX)) \
104: warning("overflow in constant expression\n"); \
105: if (needconst || VAR >= MIN && VAR <= MAX) { \
106: p = tree(CNST+ttob(TTYPE), TTYPE, 0, 0); EXP; return p; } }
107: #define cvtcnst(FTYPE,TTYPE,EXP) \
108: if (l->op == CNST+FTYPE) { \
109: p = tree(CNST+ttob(TTYPE), TTYPE, 0, 0); EXP; return p; }
110: #define commute(L,R) \
111: if (generic(R->op) == CNST && generic(L->op) != CNST) { \
112: Tree t = L; L = R; R = t; }
113: #define zerofield(OP,TYPE,VAR) \
114: if (l->op == FIELD && r->op == CNST+TYPE && r->u.v.VAR == 0) \
115: return eqnode(OP, bitnode(BAND, l->kids[0], \
116: constnode(fieldmask(l->u.field)<<fieldright(l->u.field), \
117: unsignedtype)), r);
118: #define ufoldcnst(TYPE,EXP) if (l->op == CNST+TYPE) return EXP
119: #define xfoldcnst(TYPE,VAR,OP,RTYPE,FUNC,MIN,MAX,needconst) \
120: if (l->op == CNST+TYPE && r->op == CNST+TYPE \
121: && FUNC((double)l->u.v.VAR,(double)r->u.v.VAR,(double)MIN,(double)MAX, needconst)) { \
122: p = tree(CNST+ttob(RTYPE), RTYPE, 0, 0); \
123: p->u.v.VAR = l->u.v.VAR OP r->u.v.VAR; return p; }
124: #define foldcnst(TYPE,VAR,OP,RTYPE) \
125: if (l->op == CNST+TYPE && r->op == CNST+TYPE) { \
126: p = tree(CNST+ttob(RTYPE), RTYPE, 0, 0); \
127: p->u.v.VAR = l->u.v.VAR OP r->u.v.VAR; return p; }
128: #define cfoldcnst(TYPE,VAR,OP,RTYPE) \
129: if (l->op == CNST+TYPE && r->op == CNST+TYPE) { \
130: p = tree(CNST+ttob(RTYPE), RTYPE, 0, 0); \
131: p->u.v.i = l->u.v.VAR OP r->u.v.VAR; return p; }
132: #define sfoldcnst(TYPE,VAR,OP,RTYPE) \
133: if (l->op == CNST+TYPE && r->op == CNST+I \
134: && r->u.v.i >= 0 && r->u.v.i < 8*l->type->size) { \
135: p = tree(CNST+ttob(RTYPE), RTYPE, 0, 0); \
136: p->u.v.VAR = l->u.v.VAR OP r->u.v.i; return p; }
137: #define foldaddp(L,R,RTYPE,VAR) \
138: if (L->op == CNST+P && R->op == CNST+RTYPE) { \
139: p = tree(CNST+P, ty, 0, 0); \
140: p->u.v.p = L->u.v.p + R->u.v.VAR; return p; }
141: #define geu(L,R,V) \
142: if (R->op == CNST+U && R->u.v.u == 0) { \
143: warning("result of unsigned comparison is constant\n"); \
144: return tree(RIGHT, inttype, root(L), constnode(V, inttype)); }
145: #define idempotent(OP) if (l->op == OP) return l->kids[0];
146: #define identity(X,Y,TYPE,VAR,VAL) if (X->op == CNST+TYPE && X->u.v.VAR == VAL) return Y
147:
148: /* simplify - build node for op, simplifying and folding constants, if possible */
149: Tree simplify(op, ty, l, r) Type ty; Tree l, r; {
150: int n;
151: Tree p;
152:
153: if (optype(op) == 0)
154: op += ttob(ty);
155: switch (op) {
156: case ADD+D:
157: xfoldcnst(D,d,+,doubletype,add,-DBL_MAX,DBL_MAX,0);
158: commute(r,l);
159: break;
160: case ADD+F:
161: xfoldcnst(F,f,+,floattype,add,-FLT_MAX,FLT_MAX,0);
162: commute(r,l);
163: break;
164: case ADD+I:
165: xfoldcnst(I,i,+,inttype,add,INT_MIN,INT_MAX,needconst);
166: commute(r,l);
167: break;
168: case ADD+P:
169: foldaddp(l,r,I,i);
170: foldaddp(l,r,U,u);
171: foldaddp(r,l,I,i);
172: foldaddp(r,l,U,u);
173: commute(r,l);
174: identity(r,retype(l,ty),I,i,0);
175: identity(r,retype(l,ty),U,u,0);
176: if (isaddrop(l->op) && (r->op == CNST+I || r->op == CNST+U))
177: /* l + c => l+c, where l is a symbolic address */
178: return addrnode(l->u.sym, r->op == CNST+I ? r->u.v.i : r->u.v.u, ty);
179: if ((l->op == ADD+I || l->op == SUB+I)
180: && l->kids[1]->op == CNST+I && isaddrop(r->op))
181: /* (x +- c) + r => x + r+-c, where r is a symbolic address */
182: return simplify(ADD+P, ty, l->kids[0],
183: simplify(l->op == ADD+I ? ADD+P : SUB+P, ty, r, l->kids[1]));
184: if (l->op == ADD+P && isaddrop(l->kids[1]->op)
185: && (r->op == CNST+I || r->op == CNST+U))
186: /* (x + a) + r => x + a+r */
187: return simplify(ADD+P, ty, l->kids[0],
188: addrnode(l->kids[1]->u.sym, r->op == CNST+I ? r->u.v.i : r->u.v.u, ty));
189: if (l->op == ADD+P && generic(l->kids[1]->op) == CNST && generic(r->op) == CNST)
190: /* (x + c) + r => x + c+r */
191: return simplify(ADD+P, ty, l->kids[0], (*opnode['+'])(ADD, l->kids[1], r));
192: if (l->op == ADD+I && generic(l->kids[1]->op) == CNST
193: && r->op == ADD+P && generic(r->kids[1]->op) == CNST)
194: /* (x + c1) + (y + c2) => x + (y + c1+c2) */
195: return simplify(ADD+P, ty, l->kids[0],
196: simplify(ADD+P, ty, r->kids[0],
197: (*opnode['+'])(ADD, l->kids[1], r->kids[1])));
198: if (l->op == RIGHT && isstruct(l->type)) /* f().x */
199: return tree(RIGHT, ty, l->kids[0],
200: simplify(ADD+P, ty, l->kids[1], r));
201: if (l->op == RIGHT)
202: if (l->kids[1])
203: return tree(RIGHT, ty, l->kids[0],
204: simplify(ADD+P, ty, l->kids[1], r));
205: else
206: return tree(RIGHT, ty,
207: simplify(ADD+P, ty, l->kids[0], r), 0);
208: break;
209: case ADD+U:
210: foldcnst(U,u,+,unsignedtype);
211: commute(r,l);
212: break;
213: case AND+I:
214: op = AND;
215: ufoldcnst(I,l->u.v.i ? cond(r) : l); /* 0&&r => 0, 1&&r => r */
216: break;
217: case OR+I:
218: op = OR;
219: /* 0||r => r, 1||r => 1 */
220: ufoldcnst(I,l->u.v.i ? constnode(1, inttype) : cond(r));
221: break;
222: case BAND+U:
223: foldcnst(U,u,&,unsignedtype);
224: commute(r,l);
225: identity(r,l,U,u,(~0));
226: if (r->op == CNST+U && r->u.v.u == 0) /* l&0 => (l,0) */
227: return tree(RIGHT, unsignedtype, root(l),
228: constnode(0, unsignedtype));
229: break;
230: case BCOM+I:
231: ufoldcnst(I,constnode(~l->u.v.i, inttype));
232: idempotent(BCOM+U);
233: op = BCOM+U;
234: break;
235: case BCOM+U:
236: ufoldcnst(U,constnode(~l->u.v.u, unsignedtype));
237: idempotent(BCOM+U);
238: break;
239: case BOR+U:
240: foldcnst(U,u,|,unsignedtype);
241: commute(r,l);
242: identity(r,l,U,u,0);
243: break;
244: case BXOR+U:
245: foldcnst(U,u,^,unsignedtype);
246: commute(r,l);
247: identity(r,l,U,u,0);
248: break;
249: case CVC+I: cvtcnst(C, inttype,p->u.v.i = (l->u.v.sc&0200 ? (~0<<8) : 0)|(l->u.v.sc&0377)); break;
250: case CVC+U: cvtcnst(C, unsignedtype,p->u.v.u = l->u.v.uc); break;
251: case CVD+F: xcvtcnst(D, floattype,p->u.v.f = l->u.v.d,l->u.v.d,-FLT_MAX,FLT_MAX); break;
252: case CVD+I: xcvtcnst(D, inttype,p->u.v.i = l->u.v.d,l->u.v.d,INT_MIN,INT_MAX); break;
253: case CVF+D: cvtcnst(F, doubletype,p->u.v.d = l->u.v.f); break;
254: case CVI+C: xcvtcnst(I, chartype,p->u.v.sc = l->u.v.i,l->u.v.i,SCHAR_MIN,SCHAR_MAX); break;
255: case CVI+D: cvtcnst(I, doubletype,p->u.v.d = l->u.v.i); break;
256: case CVI+S: xcvtcnst(I, shorttype,p->u.v.ss = l->u.v.i,l->u.v.i,SHRT_MIN,SHRT_MAX); break;
257: case CVI+U: cvtcnst(I, unsignedtype,p->u.v.u = l->u.v.i); break;
258: case CVP+U: cvtcnst(P, unsignedtype,p->u.v.u = (unsigned)l->u.v.p); break;
259: case CVS+I: cvtcnst(S, inttype,p->u.v.i = l->u.v.ss); break;
260: case CVS+U: cvtcnst(S, unsignedtype,p->u.v.u = l->u.v.us); break;
261: case CVU+C: cvtcnst(U, unsignedchar,p->u.v.uc = l->u.v.u); break;
262: case CVU+D: cvtcnst(U, doubletype,p->u.v.d = utod(l->u.v.u)); break;
263: case CVU+I:
264: if (needconst && l->u.v.u > INT_MAX)
265: warning("overflow in constant expression\n");
266: if (needconst || l->u.v.u <= INT_MAX)
267: cvtcnst(U, inttype,p->u.v.i = l->u.v.u);
268: break;
269: case CVU+P: cvtcnst(U, voidptype,p->u.v.p = (char *)l->u.v.u); break;
270: case CVU+S: cvtcnst(U,unsignedshort,p->u.v.us = l->u.v.u); break;
271: case DIV+D:
272: xfoldcnst(D,d,/,doubletype,div,-DBL_MAX,DBL_MAX,0);
273: break;
274: case DIV+F:
275: xfoldcnst(F,f,/,floattype,div,-FLT_MAX,FLT_MAX,0);
276: break;
277: case DIV+I:
278: identity(r,l,I,i,1);
279: #ifdef mips
280: if (l->op == CNST+I && r->op == CNST+I && r->u.v.i == -1
281: && !div((double)l->u.v.i, (double)r->u.v.i, (double)INT_MIN, (double)INT_MAX, 0))
282: break;
283: #endif
284: xfoldcnst(I,i,/,inttype,div,INT_MIN,INT_MAX,needconst);
285: break;
286: case DIV+U:
287: identity(r,l,U,u,1);
288: if (r->op == CNST+U && r->u.v.u == 0)
289: break;
290: if (r->op == CNST+U && (n = ispow2(r->u.v.u)))
291: return simplify(RSH+U, unsignedtype, l, constnode(n, inttype));
292: foldcnst(U,u,/,unsignedtype);
293: break;
294: case EQ+D:
295: cfoldcnst(D,d,==,inttype);
296: commute(r,l);
297: break;
298: case EQ+F:
299: cfoldcnst(F,f,==,inttype);
300: commute(r,l);
301: break;
302: case EQ+I:
303: cfoldcnst(I,i,==,inttype);
304: commute(r,l);
305: zerofield(EQ,I,i);
306: break;
307: case EQ+U:
308: cfoldcnst(U,u,==,inttype);
309: commute(r,l);
310: zerofield(EQ,U,u);
311: op = EQ+I;
312: break;
313: case GE+D: cfoldcnst(D,d,>=,inttype); break;
314: case GE+F: cfoldcnst(F,f,>=,inttype); break;
315: case GE+I: cfoldcnst(I,i,>=,inttype); break;
316: case GE+U:
317: geu(l,r,1); /* l >= 0 => (l,1) */
318: cfoldcnst(U,u,>=,inttype);
319: if (l->op == CNST+U && l->u.v.u == 0) /* 0 >= r => 0 == r */
320: return tree(EQ+I, ty, l, r);
321: break;
322: case GT+D: cfoldcnst(D,d, >,inttype); break;
323: case GT+F: cfoldcnst(F,f, >,inttype); break;
324: case GT+I: cfoldcnst(I,i, >,inttype); break;
325: case GT+U:
326: geu(r,l,0); /* 0 > r => (r,0) */
327: cfoldcnst(U,u, >,inttype);
328: if (r->op == CNST+U && r->u.v.u == 0) /* l > 0 => l != 0 */
329: return tree(NE+I, ty, l, r);
330: break;
331: case LE+D: cfoldcnst(D,d,<=,inttype); break;
332: case LE+F: cfoldcnst(F,f,<=,inttype); break;
333: case LE+I: cfoldcnst(I,i,<=,inttype); break;
334: case LE+U:
335: geu(r,l,1); /* 0 <= r => (r,1) */
336: cfoldcnst(U,u,<=,inttype);
337: if (r->op == CNST+U && r->u.v.u == 0) /* l <= 0 => l == 0 */
338: return tree(EQ+I, ty, l, r);
339: break;
340: case LSH+I:
341: identity(r,l,I,i,0);
342: if (l->op == CNST+I && r->op == CNST+I
343: && r->u.v.i >= 0 && r->u.v.i < 8*l->type->size
344: && mul((double)l->u.v.i, (double)(1<<r->u.v.i), (double)INT_MIN, (double)INT_MAX, needconst))
345: return constnode(l->u.v.i<<r->u.v.i, inttype);
346: break;
347: case LSH+U:
348: identity(r,l,I,i,0);
349: sfoldcnst(U,u,<<,unsignedtype);
350: break;
351: case LT+D: cfoldcnst(D,d, <,inttype); break;
352: case LT+F: cfoldcnst(F,f, <,inttype); break;
353: case LT+I: cfoldcnst(I,i, <,inttype); break;
354: case LT+U:
355: geu(l,r,0); /* l < 0 => (l,0) */
356: cfoldcnst(U,u, <,inttype);
357: if (l->op == CNST+U && l->u.v.u == 0) /* 0 < r => 0 != r */
358: return tree(NE+I, ty, l, r);
359: break;
360: case MOD+I:
361: if (r->op == CNST+I && r->u.v.i == 1) /* l%1 => (l,0) */
362: return tree(RIGHT, inttype, root(l), constnode(0, inttype));
363: if (r->op == CNST+I && r->u.v.i == 0)
364: break;
365: #ifdef mips
366: if (l->op == CNST+I && r->op == CNST+I && r->u.v.i == -1
367: && !div((double)l->u.v.i, (double)r->u.v.i, (double)INT_MIN, (double)INT_MAX, 0))
368: break;
369: #endif
370: xfoldcnst(I,i,%,inttype,div,INT_MIN,INT_MAX,needconst);
371: break;
372: case MOD+U:
373: if (r->op == CNST+U && ispow2(r->u.v.u)) /* l%2^n => l&(2^n-1) */
374: return bitnode(BAND, l,
375: constnode(r->u.v.u - 1, unsignedtype));
376: if (r->op == CNST+U && r->u.v.u == 0)
377: break;
378: foldcnst(U,u,%,unsignedtype);
379: break;
380: case MUL+D:
381: xfoldcnst(D,d,*,doubletype,mul,-DBL_MAX,DBL_MAX,0);
382: commute(l,r);
383: break;
384: case MUL+F:
385: xfoldcnst(F,f,*,floattype,mul,-FLT_MAX,FLT_MAX,0);
386: commute(l,r);
387: break;
388: case MUL+I:
389: commute(l,r);
390: if (l->op == CNST+I && r->op == ADD+I && r->kids[1]->op == CNST+I)
391: /* c1*(x + c2) => c1*x + c1*c2 */
392: return simplify(ADD+I, inttype, simplify(MUL+I, inttype, l, r->kids[0]),
393: simplify(MUL+I, inttype, l, r->kids[1]));
394: if (l->op == CNST+I && r->op == SUB+I && r->kids[1]->op == CNST+I)
395: /* c1*(x - c2) => c1*x - c1*c2 */
396: return simplify(SUB+I, inttype, simplify(MUL+I, inttype, l, r->kids[0]),
397: simplify(MUL+I, inttype, l, r->kids[1]));
398: if (l->op == CNST+I && l->u.v.i > 0 && (n = ispow2(l->u.v.i)))
399: /* 2^n * r => r<<n */
400: return simplify(LSH+I, inttype, r, constnode(n, inttype));
401: xfoldcnst(I,i,*,inttype,mul,INT_MIN,INT_MAX,needconst);
402: break;
403: case MUL+U:
404: commute(l,r);
405: if (l->op == CNST+U && (n = ispow2(l->u.v.u)))
406: /* 2^n * r => r<<n */
407: return simplify(LSH+U, unsignedtype, r, constnode(n, inttype));
408: foldcnst(U,u,*,unsignedtype);
409: break;
410: case NE+D:
411: foldcnst(D,d,!=,inttype);
412: commute(r,l);
413: break;
414: case NE+F:
415: cfoldcnst(F,f,!=,inttype);
416: commute(r,l);
417: break;
418: case NE+I:
419: cfoldcnst(I,i,!=,inttype);
420: commute(r,l);
421: zerofield(NE,I,i);
422: break;
423: case NE+U:
424: cfoldcnst(U,u,!=,inttype);
425: commute(r,l);
426: zerofield(NE,U,u);
427: op = NE+I;
428: break;
429: case NEG+D:
430: ufoldcnst(D,(p = tree(CNST+D, doubletype, 0, 0), p->u.v.d = -l->u.v.d, p));
431: idempotent(NEG+D);
432: break;
433: case NEG+F:
434: ufoldcnst(F,(p = tree(CNST+F, floattype, 0, 0), p->u.v.f = -l->u.v.f, p));
435: idempotent(NEG+F);
436: break;
437: case NEG+I:
438: if (l->op == CNST+I) {
439: if (needconst && l->u.v.i == INT_MIN)
440: warning("overflow in constant expression\n");
441: if (needconst || l->u.v.i != INT_MIN)
442: return constnode(-l->u.v.i, inttype);
443: }
444: idempotent(NEG+I);
445: break;
446: case NOT+I:
447: op = NOT;
448: ufoldcnst(I,constnode(!l->u.v.i, inttype));
449: break;
450: case RSH+I:
451: identity(r,l,I,i,0);
452: if (l->op == CNST+I && r->op == CNST+I
453: && r->u.v.i >= 0 && r->u.v.i < 8*l->type->size) {
454: int n = l->u.v.i>>r->u.v.i;
455: if (l->u.v.i < 0)
456: n |= ~0<<(8*l->type->size - r->u.v.i);
457: return constnode(n, inttype);
458: }
459: break;
460: case RSH+U:
461: identity(r,l,I,i,0);
462: sfoldcnst(U,u,>>,unsignedtype);
463: break;
464: case SUB+D:
465: xfoldcnst(D,d,-,doubletype,sub,-DBL_MAX,DBL_MAX,0);
466: break;
467: case SUB+F:
468: xfoldcnst(F,f,-,floattype,sub,-FLT_MAX,FLT_MAX,0);
469: break;
470: case SUB+I:
471: xfoldcnst(I,i,-,inttype,sub,INT_MIN,INT_MAX,needconst);
472: break;
473: case SUB+U:
474: foldcnst(U,u,-,unsignedtype);
475: break;
476: case SUB+P:
477: if (l->op == CNST+P && r->op == CNST+P)
478: return constnode(l->u.v.p - r->u.v.p, inttype);
479: if (r->op == CNST+I || r->op == CNST+U)
480: return simplify(ADD+P, ty, l,
481: constnode(r->op == CNST+I ? -r->u.v.i : -(int)r->u.v.u, inttype));
482: if (isaddrop(l->op) && r->op == ADD+I && r->kids[1]->op == CNST+I)
483: /* l - (x + c) => l-c - x */
484: return simplify(SUB+P, ty,
485: simplify(SUB+P, ty, l, r->kids[1]), r->kids[0]);
486: break;
487: default:assert(0);
488: }
489: return tree(op, ty, l, r);
490: }
491:
492: /* sub - return 1 if min <= x-y <= max, 0 otherwise */
493: static int sub(x, y, min, max, needconst) double x, y, min, max; {
494: return add(x, -y, min, max, needconst);
495: }
496:
497: /* vtoa - return string for the constant v of type ty */
498: char *vtoa(ty, v) Type ty; Value v; {
499: char buf[50];
500:
501: ty = unqual(ty);
502: switch (ty->op) {
503: case CHAR:
504: return stringf("%d", v.uc);
505: case SHORT:
506: return stringf("%d", v.ss);
507: case INT:
508: return stringf("%d", v.i);
509: case UNSIGNED:
510: if ((v.u&~0x7fff) == 0)
511: return stringf("%d", v.u);
512: else
513: return stringf("0x%x", v.u);
514: case FLOAT:
515: if (v.f == 0.0)
516: return "0";
517: sprintf(buf, "%.*g", 8, v.f);
518: return string(buf);
519: case DOUBLE:
520: if (v.d == 0.0)
521: return "0";
522: sprintf(buf, "%.*g", 18, v.d);
523: return string(buf);
524: case ARRAY:
525: if (ty->type->op == CHAR)
526: return v.p;
527: /* else fall thru */
528: case POINTER: case FUNCTION:
529: if (((unsigned)v.p&~0x7fff) == 0)
530: return stringf("%d", v.p);
531: else
532: return stringf("0x%x", v.p);
533: default:assert(0);
534: }
535: return 0;
536: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.