?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d: Merge upstream dmd, druntime 4ca4140e58, phobos 454dff14d.
[official-gcc.git] / gcc / d / dmd / constfold.d
blobe4be63cda3e5261122c2f24644e72174eefd9061
1 /**
2 * Perform constant folding of arithmetic expressions.
3 *
4 * The routines in this module are called from `optimize.d`.
5 *
6 * Specification: $(LINK2 https://dlang.org/spec/float.html#fp_const_folding, Floating Point Constant Folding)
7 *
8 * Copyright: Copyright (C) 1999-2023 by The D Language Foundation, All Rights Reserved
9 * Authors: $(LINK2 https://www.digitalmars.com, Walter Bright)
10 * License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
11 * Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/dmd/constfold.d, _constfold.d)
12 * Documentation: https://dlang.org/phobos/dmd_constfold.html
13 * Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/constfold.d
14 */
15
16 module dmd.constfold;
17
18 import core.stdc.string;
19 import core.stdc.stdio;
20 import dmd.arraytypes;
21 import dmd.astenums;
22 import dmd.ctfeexpr;
23 import dmd.declaration;
24 import dmd.dstruct;
25 import dmd.errors;
26 import dmd.expression;
27 import dmd.globals;
28 import dmd.location;
29 import dmd.mtype;
30 import dmd.root.complex;
31 import dmd.root.ctfloat;
32 import dmd.root.port;
33 import dmd.root.rmem;
34 import dmd.root.utf;
35 import dmd.sideeffect;
36 import dmd.target;
37 import dmd.tokens;
38
39 private enum LOG = false;
40
41 private Expression expType(Type type, Expression e)
42 {
43 if (type != e.type)
44 {
45 e = e.copy();
46 e.type = type;
47 }
48 return e;
49 }
50
51 /************************************
52 * Returns:
53 * true if e is a constant
54 */
55 int isConst(Expression e)
56 {
57 //printf("Expression::isConst(): %s\n", e.toChars());
58 switch (e.op)
59 {
60 case EXP.int64:
61 case EXP.float64:
62 case EXP.complex80:
63 return 1;
64 case EXP.null_:
65 return 0;
66 case EXP.symbolOffset:
67 return 2;
68 default:
69 return 0;
70 }
71 assert(0);
72 }
73
74 /**********************************
75 * Initialize a EXP.cantExpression Expression.
76 * Params:
77 * ue = where to write it
78 */
79 void cantExp(out UnionExp ue)
80 {
81 emplaceExp!(CTFEExp)(&ue, EXP.cantExpression);
82 }
83
84 /* =============================== constFold() ============================== */
85 /* The constFold() functions were redundant with the optimize() ones,
86 * and so have been folded in with them.
87 */
88 /* ========================================================================== */
89 UnionExp Neg(Type type, Expression e1)
90 {
91 UnionExp ue = void;
92 Loc loc = e1.loc;
93 if (e1.type.isreal())
94 {
95 emplaceExp!(RealExp)(&ue, loc, -e1.toReal(), type);
96 }
97 else if (e1.type.isimaginary())
98 {
99 emplaceExp!(RealExp)(&ue, loc, -e1.toImaginary(), type);
100 }
101 else if (e1.type.iscomplex())
102 {
103 emplaceExp!(ComplexExp)(&ue, loc, -e1.toComplex(), type);
104 }
105 else
106 {
107 emplaceExp!(IntegerExp)(&ue, loc, -e1.toInteger(), type);
108 }
109 return ue;
110 }
111
112 UnionExp Com(Type type, Expression e1)
113 {
114 UnionExp ue = void;
115 Loc loc = e1.loc;
116 emplaceExp!(IntegerExp)(&ue, loc, ~e1.toInteger(), type);
117 return ue;
118 }
119
120 UnionExp Not(Type type, Expression e1)
121 {
122 UnionExp ue = void;
123 Loc loc = e1.loc;
124 // BUG: Should be replaced with e1.toBool().get(), but this is apparently
125 // executed for some expressions that cannot be const-folded
126 // To be fixed in another PR
127 emplaceExp!(IntegerExp)(&ue, loc, e1.toBool().hasValue(false) ? 1 : 0, type);
128 return ue;
129 }
130
131 UnionExp Add(const ref Loc loc, Type type, Expression e1, Expression e2)
132 {
133 UnionExp ue = void;
134 static if (LOG)
135 {
136 printf("Add(e1 = %s, e2 = %s)\n", e1.toChars(), e2.toChars());
137 }
138 if (type.isreal())
139 {
140 emplaceExp!(RealExp)(&ue, loc, e1.toReal() + e2.toReal(), type);
141 }
142 else if (type.isimaginary())
143 {
144 emplaceExp!(RealExp)(&ue, loc, e1.toImaginary() + e2.toImaginary(), type);
145 }
146 else if (type.iscomplex())
147 {
148 // This rigamarole is necessary so that -0.0 doesn't get
149 // converted to +0.0 by doing an extraneous add with +0.0
150 auto c1 = complex_t(CTFloat.zero);
151 real_t r1 = CTFloat.zero;
152 real_t i1 = CTFloat.zero;
153 auto c2 = complex_t(CTFloat.zero);
154 real_t r2 = CTFloat.zero;
155 real_t i2 = CTFloat.zero;
156 auto v = complex_t(CTFloat.zero);
157 int x;
158 if (e1.type.isreal())
159 {
160 r1 = e1.toReal();
161 x = 0;
162 }
163 else if (e1.type.isimaginary())
164 {
165 i1 = e1.toImaginary();
166 x = 3;
167 }
168 else
169 {
170 c1 = e1.toComplex();
171 x = 6;
172 }
173 if (e2.type.isreal())
174 {
175 r2 = e2.toReal();
176 }
177 else if (e2.type.isimaginary())
178 {
179 i2 = e2.toImaginary();
180 x += 1;
181 }
182 else
183 {
184 c2 = e2.toComplex();
185 x += 2;
186 }
187 switch (x)
188 {
189 case 0 + 0:
190 v = complex_t(r1 + r2);
191 break;
192 case 0 + 1:
193 v = complex_t(r1, i2);
194 break;
195 case 0 + 2:
196 v = complex_t(r1 + creall(c2), cimagl(c2));
197 break;
198 case 3 + 0:
199 v = complex_t(r2, i1);
200 break;
201 case 3 + 1:
202 v = complex_t(CTFloat.zero, i1 + i2);
203 break;
204 case 3 + 2:
205 v = complex_t(creall(c2), i1 + cimagl(c2));
206 break;
207 case 6 + 0:
208 v = complex_t(creall(c1) + r2, cimagl(c2));
209 break;
210 case 6 + 1:
211 v = complex_t(creall(c1), cimagl(c1) + i2);
212 break;
213 case 6 + 2:
214 v = c1 + c2;
215 break;
216 default:
217 assert(0);
218 }
219 emplaceExp!(ComplexExp)(&ue, loc, v, type);
220 }
221 else if (SymOffExp soe = e1.isSymOffExp())
222 {
223 emplaceExp!(SymOffExp)(&ue, loc, soe.var, soe.offset + e2.toInteger());
224 ue.exp().type = type;
225 }
226 else if (SymOffExp soe = e2.isSymOffExp())
227 {
228 emplaceExp!(SymOffExp)(&ue, loc, soe.var, soe.offset + e1.toInteger());
229 ue.exp().type = type;
230 }
231 else
232 emplaceExp!(IntegerExp)(&ue, loc, e1.toInteger() + e2.toInteger(), type);
233 return ue;
234 }
235
236 UnionExp Min(const ref Loc loc, Type type, Expression e1, Expression e2)
237 {
238 // Compute e1-e2 as e1+(-e2)
239 UnionExp neg = Neg(e2.type, e2);
240 UnionExp ue = Add(loc, type, e1, neg.exp());
241 return ue;
242 }
243
244 UnionExp Mul(const ref Loc loc, Type type, Expression e1, Expression e2)
245 {
246 UnionExp ue = void;
247 if (type.isfloating())
248 {
249 auto c = complex_t(CTFloat.zero);
250 real_t r = CTFloat.zero;
251 if (e1.type.isreal())
252 {
253 r = e1.toReal();
254 c = e2.toComplex();
255 c = complex_t(r * creall(c), r * cimagl(c));
256 }
257 else if (e1.type.isimaginary())
258 {
259 r = e1.toImaginary();
260 c = e2.toComplex();
261 c = complex_t(-r * cimagl(c), r * creall(c));
262 }
263 else if (e2.type.isreal())
264 {
265 r = e2.toReal();
266 c = e1.toComplex();
267 c = complex_t(r * creall(c), r * cimagl(c));
268 }
269 else if (e2.type.isimaginary())
270 {
271 r = e2.toImaginary();
272 c = e1.toComplex();
273 c = complex_t(-r * cimagl(c), r * creall(c));
274 }
275 else
276 c = e1.toComplex() * e2.toComplex();
277 if (type.isreal())
278 emplaceExp!(RealExp)(&ue, loc, creall(c), type);
279 else if (type.isimaginary())
280 emplaceExp!(RealExp)(&ue, loc, cimagl(c), type);
281 else if (type.iscomplex())
282 emplaceExp!(ComplexExp)(&ue, loc, c, type);
283 else
284 assert(0);
285 }
286 else
287 {
288 emplaceExp!(IntegerExp)(&ue, loc, e1.toInteger() * e2.toInteger(), type);
289 }
290 return ue;
291 }
292
293 UnionExp Div(const ref Loc loc, Type type, Expression e1, Expression e2)
294 {
295 UnionExp ue = void;
296 if (type.isfloating())
297 {
298 auto c = complex_t(CTFloat.zero);
299 if (e2.type.isreal())
300 {
301 if (e1.type.isreal())
302 {
303 emplaceExp!(RealExp)(&ue, loc, e1.toReal() / e2.toReal(), type);
304 return ue;
305 }
306 const r = e2.toReal();
307 c = e1.toComplex();
308 c = complex_t(creall(c) / r, cimagl(c) / r);
309 }
310 else if (e2.type.isimaginary())
311 {
312 const r = e2.toImaginary();
313 c = e1.toComplex();
314 c = complex_t(cimagl(c) / r, -creall(c) / r);
315 }
316 else
317 {
318 c = e1.toComplex() / e2.toComplex();
319 }
320
321 if (type.isreal())
322 emplaceExp!(RealExp)(&ue, loc, creall(c), type);
323 else if (type.isimaginary())
324 emplaceExp!(RealExp)(&ue, loc, cimagl(c), type);
325 else if (type.iscomplex())
326 emplaceExp!(ComplexExp)(&ue, loc, c, type);
327 else
328 assert(0);
329 }
330 else
331 {
332 sinteger_t n1;
333 sinteger_t n2;
334 sinteger_t n;
335 n1 = e1.toInteger();
336 n2 = e2.toInteger();
337 if (n2 == 0)
338 {
339 e2.error("divide by 0");
340 emplaceExp!(ErrorExp)(&ue);
341 return ue;
342 }
343 if (n2 == -1 && !type.isunsigned())
344 {
345 // Check for int.min / -1
346 if (n1 == 0xFFFFFFFF80000000UL && type.toBasetype().ty != Tint64)
347 {
348 e2.error("integer overflow: `int.min / -1`");
349 emplaceExp!(ErrorExp)(&ue);
350 return ue;
351 }
352 else if (n1 == 0x8000000000000000L) // long.min / -1
353 {
354 e2.error("integer overflow: `long.min / -1L`");
355 emplaceExp!(ErrorExp)(&ue);
356 return ue;
357 }
358 }
359 if (e1.type.isunsigned() || e2.type.isunsigned())
360 n = (cast(dinteger_t)n1) / (cast(dinteger_t)n2);
361 else
362 n = n1 / n2;
363 emplaceExp!(IntegerExp)(&ue, loc, n, type);
364 }
365 return ue;
366 }
367
368 UnionExp Mod(const ref Loc loc, Type type, Expression e1, Expression e2)
369 {
370 UnionExp ue = void;
371 if (type.isfloating())
372 {
373 auto c = complex_t(CTFloat.zero);
374 if (e2.type.isreal())
375 {
376 const r2 = e2.toReal();
377 c = complex_t(e1.toReal() % r2, e1.toImaginary() % r2);
378 }
379 else if (e2.type.isimaginary())
380 {
381 const i2 = e2.toImaginary();
382 c = complex_t(e1.toReal() % i2, e1.toImaginary() % i2);
383 }
384 else
385 assert(0);
386 if (type.isreal())
387 emplaceExp!(RealExp)(&ue, loc, creall(c), type);
388 else if (type.isimaginary())
389 emplaceExp!(RealExp)(&ue, loc, cimagl(c), type);
390 else if (type.iscomplex())
391 emplaceExp!(ComplexExp)(&ue, loc, c, type);
392 else
393 assert(0);
394 }
395 else
396 {
397 sinteger_t n1;
398 sinteger_t n2;
399 sinteger_t n;
400 n1 = e1.toInteger();
401 n2 = e2.toInteger();
402 if (n2 == 0)
403 {
404 e2.error("divide by 0");
405 emplaceExp!(ErrorExp)(&ue);
406 return ue;
407 }
408 if (n2 == -1 && !type.isunsigned())
409 {
410 // Check for int.min % -1
411 if (n1 == 0xFFFFFFFF80000000UL && type.toBasetype().ty != Tint64)
412 {
413 e2.error("integer overflow: `int.min %% -1`");
414 emplaceExp!(ErrorExp)(&ue);
415 return ue;
416 }
417 else if (n1 == 0x8000000000000000L) // long.min % -1
418 {
419 e2.error("integer overflow: `long.min %% -1L`");
420 emplaceExp!(ErrorExp)(&ue);
421 return ue;
422 }
423 }
424 if (e1.type.isunsigned() || e2.type.isunsigned())
425 n = (cast(dinteger_t)n1) % (cast(dinteger_t)n2);
426 else
427 n = n1 % n2;
428 emplaceExp!(IntegerExp)(&ue, loc, n, type);
429 }
430 return ue;
431 }
432
433 UnionExp Pow(const ref Loc loc, Type type, Expression e1, Expression e2)
434 {
435 //printf("Pow()\n");
436 UnionExp ue;
437 // Handle integer power operations.
438 if (e2.type.isintegral())
439 {
440 dinteger_t n = e2.toInteger();
441 bool neg;
442 if (!e2.type.isunsigned() && cast(sinteger_t)n < 0)
443 {
444 if (e1.type.isintegral())
445 {
446 cantExp(ue);
447 return ue;
448 }
449 // Don't worry about overflow, from now on n is unsigned.
450 neg = true;
451 n = -n;
452 }
453 else
454 neg = false;
455 UnionExp ur, uv;
456 if (e1.type.iscomplex())
457 {
458 emplaceExp!(ComplexExp)(&ur, loc, e1.toComplex(), e1.type);
459 emplaceExp!(ComplexExp)(&uv, loc, complex_t(CTFloat.one), e1.type);
460 }
461 else if (e1.type.isfloating())
462 {
463 emplaceExp!(RealExp)(&ur, loc, e1.toReal(), e1.type);
464 emplaceExp!(RealExp)(&uv, loc, CTFloat.one, e1.type);
465 }
466 else
467 {
468 emplaceExp!(IntegerExp)(&ur, loc, e1.toInteger(), e1.type);
469 emplaceExp!(IntegerExp)(&uv, loc, 1, e1.type);
470 }
471 Expression r = ur.exp();
472 Expression v = uv.exp();
473 while (n != 0)
474 {
475 if (n & 1)
476 {
477 // v = v * r;
478 uv = Mul(loc, v.type, v, r);
479 }
480 n >>= 1;
481 // r = r * r
482 ur = Mul(loc, r.type, r, r);
483 }
484 if (neg)
485 {
486 // ue = 1.0 / v
487 UnionExp one;
488 emplaceExp!(RealExp)(&one, loc, CTFloat.one, v.type);
489 uv = Div(loc, v.type, one.exp(), v);
490 }
491 if (type.iscomplex())
492 emplaceExp!(ComplexExp)(&ue, loc, v.toComplex(), type);
493 else if (type.isintegral())
494 emplaceExp!(IntegerExp)(&ue, loc, v.toInteger(), type);
495 else
496 emplaceExp!(RealExp)(&ue, loc, v.toReal(), type);
497 }
498 else if (e2.type.isfloating())
499 {
500 // x ^^ y for x < 0 and y not an integer is not defined; so set result as NaN
501 if (e1.toReal() < CTFloat.zero)
502 {
503 emplaceExp!(RealExp)(&ue, loc, target.RealProperties.nan, type);
504 }
505 else
506 cantExp(ue);
507 }
508 else
509 cantExp(ue);
510 return ue;
511 }
512
513 UnionExp Shl(const ref Loc loc, Type type, Expression e1, Expression e2)
514 {
515 UnionExp ue = void;
516 emplaceExp!(IntegerExp)(&ue, loc, e1.toInteger() << e2.toInteger(), type);
517 return ue;
518 }
519
520 UnionExp Shr(const ref Loc loc, Type type, Expression e1, Expression e2)
521 {
522 UnionExp ue = void;
523 dinteger_t value = e1.toInteger();
524 dinteger_t dcount = e2.toInteger();
525 assert(dcount <= 0xFFFFFFFF);
526 uint count = cast(uint)dcount;
527 switch (e1.type.toBasetype().ty)
528 {
529 case Tint8:
530 value = cast(byte)value >> count;
531 break;
532 case Tuns8:
533 case Tchar:
534 value = cast(ubyte)value >> count;
535 break;
536 case Tint16:
537 value = cast(short)value >> count;
538 break;
539 case Tuns16:
540 case Twchar:
541 value = cast(ushort)value >> count;
542 break;
543 case Tint32:
544 value = cast(int)value >> count;
545 break;
546 case Tuns32:
547 case Tdchar:
548 value = cast(uint)value >> count;
549 break;
550 case Tint64:
551 value = cast(long)value >> count;
552 break;
553 case Tuns64:
554 value = cast(ulong)value >> count;
555 break;
556 case Terror:
557 emplaceExp!(ErrorExp)(&ue);
558 return ue;
559 default:
560 assert(0);
561 }
562 emplaceExp!(IntegerExp)(&ue, loc, value, type);
563 return ue;
564 }
565
566 UnionExp Ushr(const ref Loc loc, Type type, Expression e1, Expression e2)
567 {
568 UnionExp ue = void;
569 dinteger_t value = e1.toInteger();
570 dinteger_t dcount = e2.toInteger();
571 assert(dcount <= 0xFFFFFFFF);
572 uint count = cast(uint)dcount;
573 switch (e1.type.toBasetype().ty)
574 {
575 case Tint8:
576 case Tuns8:
577 case Tchar:
578 // Possible only with >>>=. >>> always gets promoted to int.
579 value = (value & 0xFF) >>> count;
580 break;
581 case Tint16:
582 case Tuns16:
583 case Twchar:
584 // Possible only with >>>=. >>> always gets promoted to int.
585 value = (value & 0xFFFF) >>> count;
586 break;
587 case Tint32:
588 case Tuns32:
589 case Tdchar:
590 value = (value & 0xFFFFFFFF) >>> count;
591 break;
592 case Tint64:
593 case Tuns64:
594 value = value >>> count;
595 break;
596 case Terror:
597 emplaceExp!(ErrorExp)(&ue);
598 return ue;
599 default:
600 assert(0);
601 }
602 emplaceExp!(IntegerExp)(&ue, loc, value, type);
603 return ue;
604 }
605
606 UnionExp And(const ref Loc loc, Type type, Expression e1, Expression e2)
607 {
608 UnionExp ue = void;
609 emplaceExp!(IntegerExp)(&ue, loc, e1.toInteger() & e2.toInteger(), type);
610 return ue;
611 }
612
613 UnionExp Or(const ref Loc loc, Type type, Expression e1, Expression e2)
614 {
615 UnionExp ue = void;
616 emplaceExp!(IntegerExp)(&ue, loc, e1.toInteger() | e2.toInteger(), type);
617 return ue;
618 }
619
620 UnionExp Xor(const ref Loc loc, Type type, Expression e1, Expression e2)
621 {
622 //printf("Xor(linnum = %d, e1 = %s, e2 = %s)\n", loc.linnum, e1.toChars(), e2.toChars());
623 UnionExp ue = void;
624 emplaceExp!(IntegerExp)(&ue, loc, e1.toInteger() ^ e2.toInteger(), type);
625 return ue;
626 }
627
628 /* Also returns EXP.cantExpression if cannot be computed.
629 */
630 UnionExp Equal(EXP op, const ref Loc loc, Type type, Expression e1, Expression e2)
631 {
632 UnionExp ue = void;
633 int cmp = 0;
634 real_t r1 = CTFloat.zero;
635 real_t r2 = CTFloat.zero;
636 //printf("Equal(e1 = %s, e2 = %s)\n", e1.toChars(), e2.toChars());
637 assert(op == EXP.equal || op == EXP.notEqual);
638 if (e1.op == EXP.null_)
639 {
640 if (e2.op == EXP.null_)
641 cmp = 1;
642 else if (StringExp es2 = e2.isStringExp())
643 {
644 cmp = (0 == es2.len);
645 }
646 else if (ArrayLiteralExp es2 = e2.isArrayLiteralExp())
647 {
648 cmp = !es2.elements || (0 == es2.elements.length);
649 }
650 else
651 {
652 cantExp(ue);
653 return ue;
654 }
655 }
656 else if (e2.op == EXP.null_)
657 {
658 if (StringExp es1 = e1.isStringExp())
659 {
660 cmp = (0 == es1.len);
661 }
662 else if (ArrayLiteralExp es1 = e1.isArrayLiteralExp())
663 {
664 cmp = !es1.elements || (0 == es1.elements.length);
665 }
666 else
667 {
668 cantExp(ue);
669 return ue;
670 }
671 }
672 else if (e1.op == EXP.string_ && e2.op == EXP.string_)
673 {
674 StringExp es1 = e1.isStringExp();
675 StringExp es2 = e2.isStringExp();
676 if (es1.sz != es2.sz)
677 {
678 assert(global.errors);
679 cantExp(ue);
680 return ue;
681 }
682 const data1 = es1.peekData();
683 const data2 = es2.peekData();
684 if (es1.len == es2.len && memcmp(data1.ptr, data2.ptr, es1.sz * es1.len) == 0)
685 cmp = 1;
686 else
687 cmp = 0;
688 }
689 else if (e1.op == EXP.arrayLiteral && e2.op == EXP.arrayLiteral)
690 {
691 ArrayLiteralExp es1 = e1.isArrayLiteralExp();
692 ArrayLiteralExp es2 = e2.isArrayLiteralExp();
693 if ((!es1.elements || !es1.elements.length) && (!es2.elements || !es2.elements.length))
694 cmp = 1; // both arrays are empty
695 else if (!es1.elements || !es2.elements)
696 cmp = 0;
697 else if (es1.elements.length != es2.elements.length)
698 cmp = 0;
699 else
700 {
701 for (size_t i = 0; i < es1.elements.length; i++)
702 {
703 auto ee1 = es1[i];
704 auto ee2 = es2[i];
705 ue = Equal(EXP.equal, loc, Type.tint32, ee1, ee2);
706 if (CTFEExp.isCantExp(ue.exp()))
707 return ue;
708 cmp = cast(int)ue.exp().toInteger();
709 if (cmp == 0)
710 break;
711 }
712 }
713 }
714 else if (e1.op == EXP.arrayLiteral && e2.op == EXP.string_)
715 {
716 // Swap operands and use common code
717 Expression etmp = e1;
718 e1 = e2;
719 e2 = etmp;
720 goto Lsa;
721 }
722 else if (e1.op == EXP.string_ && e2.op == EXP.arrayLiteral)
723 {
724 Lsa:
725 StringExp es1 = e1.isStringExp();
726 ArrayLiteralExp es2 = e2.isArrayLiteralExp();
727 size_t dim1 = es1.len;
728 size_t dim2 = es2.elements ? es2.elements.length : 0;
729 if (dim1 != dim2)
730 cmp = 0;
731 else
732 {
733 cmp = 1; // if dim1 winds up being 0
734 foreach (i; 0 .. dim1)
735 {
736 uinteger_t c = es1.getCodeUnit(i);
737 auto ee2 = es2[i];
738 if (ee2.isConst() != 1)
739 {
740 cantExp(ue);
741 return ue;
742 }
743 cmp = (c == ee2.toInteger());
744 if (cmp == 0)
745 break;
746 }
747 }
748 }
749 else if (e1.op == EXP.structLiteral && e2.op == EXP.structLiteral)
750 {
751 StructLiteralExp es1 = e1.isStructLiteralExp();
752 StructLiteralExp es2 = e2.isStructLiteralExp();
753 if (es1.sd != es2.sd)
754 cmp = 0;
755 else if ((!es1.elements || !es1.elements.length) && (!es2.elements || !es2.elements.length))
756 cmp = 1; // both arrays are empty
757 else if (!es1.elements || !es2.elements)
758 cmp = 0;
759 else if (es1.elements.length != es2.elements.length)
760 cmp = 0;
761 else
762 {
763 cmp = 1;
764 for (size_t i = 0; i < es1.elements.length; i++)
765 {
766 Expression ee1 = (*es1.elements)[i];
767 Expression ee2 = (*es2.elements)[i];
768 if (ee1 == ee2)
769 continue;
770 if (!ee1 || !ee2)
771 {
772 cmp = 0;
773 break;
774 }
775 ue = Equal(EXP.equal, loc, Type.tint32, ee1, ee2);
776 if (ue.exp().op == EXP.cantExpression)
777 return ue;
778 cmp = cast(int)ue.exp().toInteger();
779 if (cmp == 0)
780 break;
781 }
782 }
783 }
784 else if (e1.isConst() != 1 || e2.isConst() != 1)
785 {
786 cantExp(ue);
787 return ue;
788 }
789 else if (e1.type.isreal())
790 {
791 r1 = e1.toReal();
792 r2 = e2.toReal();
793 goto L1;
794 }
795 else if (e1.type.isimaginary())
796 {
797 r1 = e1.toImaginary();
798 r2 = e2.toImaginary();
799 L1:
800 if (CTFloat.isNaN(r1) || CTFloat.isNaN(r2)) // if unordered
801 {
802 cmp = 0;
803 }
804 else
805 {
806 cmp = (r1 == r2);
807 }
808 }
809 else if (e1.type.iscomplex())
810 {
811 cmp = e1.toComplex() == e2.toComplex();
812 }
813 else if (e1.type.isintegral() || e1.type.toBasetype().ty == Tpointer)
814 {
815 cmp = (e1.toInteger() == e2.toInteger());
816 }
817 else
818 {
819 cantExp(ue);
820 return ue;
821 }
822 if (op == EXP.notEqual)
823 cmp ^= 1;
824 emplaceExp!(IntegerExp)(&ue, loc, cmp, type);
825 return ue;
826 }
827
828 UnionExp Identity(EXP op, const ref Loc loc, Type type, Expression e1, Expression e2)
829 {
830 UnionExp ue = void;
831 int cmp;
832 if (e1.op == EXP.null_)
833 {
834 cmp = (e2.op == EXP.null_);
835 }
836 else if (e2.op == EXP.null_)
837 {
838 cmp = 0;
839 }
840 else if (e1.op == EXP.symbolOffset && e2.op == EXP.symbolOffset)
841 {
842 SymOffExp es1 = e1.isSymOffExp();
843 SymOffExp es2 = e2.isSymOffExp();
844 cmp = (es1.var == es2.var && es1.offset == es2.offset);
845 }
846 else
847 {
848 if (e1.type.isfloating())
849 cmp = e1.isIdentical(e2);
850 else
851 {
852 ue = Equal((op == EXP.identity) ? EXP.equal : EXP.notEqual, loc, type, e1, e2);
853 return ue;
854 }
855 }
856 if (op == EXP.notIdentity)
857 cmp ^= 1;
858 emplaceExp!(IntegerExp)(&ue, loc, cmp, type);
859 return ue;
860 }
861
862 UnionExp Cmp(EXP op, const ref Loc loc, Type type, Expression e1, Expression e2)
863 {
864 UnionExp ue = void;
865 dinteger_t n;
866 real_t r1 = CTFloat.zero;
867 real_t r2 = CTFloat.zero;
868 //printf("Cmp(e1 = %s, e2 = %s)\n", e1.toChars(), e2.toChars());
869 if (e1.op == EXP.string_ && e2.op == EXP.string_)
870 {
871 StringExp es1 = e1.isStringExp();
872 StringExp es2 = e2.isStringExp();
873 size_t sz = es1.sz;
874 assert(sz == es2.sz);
875 size_t len = es1.len;
876 if (es2.len < len)
877 len = es2.len;
878 const data1 = es1.peekData();
879 const data2 = es1.peekData();
880 int rawCmp = memcmp(data1.ptr, data2.ptr, sz * len);
881 if (rawCmp == 0)
882 rawCmp = cast(int)(es1.len - es2.len);
883 n = specificCmp(op, rawCmp);
884 }
885 else if (e1.isConst() != 1 || e2.isConst() != 1)
886 {
887 cantExp(ue);
888 return ue;
889 }
890 else if (e1.type.isreal())
891 {
892 r1 = e1.toReal();
893 r2 = e2.toReal();
894 goto L1;
895 }
896 else if (e1.type.isimaginary())
897 {
898 r1 = e1.toImaginary();
899 r2 = e2.toImaginary();
900 L1:
901 n = realCmp(op, r1, r2);
902 }
903 else if (e1.type.iscomplex())
904 {
905 assert(0);
906 }
907 else
908 {
909 sinteger_t n1;
910 sinteger_t n2;
911 n1 = e1.toInteger();
912 n2 = e2.toInteger();
913 if (e1.type.isunsigned() || e2.type.isunsigned())
914 n = intUnsignedCmp(op, n1, n2);
915 else
916 n = intSignedCmp(op, n1, n2);
917 }
918 emplaceExp!(IntegerExp)(&ue, loc, n, type);
919 return ue;
920 }
921
922 /* Also returns EXP.cantExpression if cannot be computed.
923 * to: type to cast to
924 * type: type to paint the result
925 */
926 UnionExp Cast(const ref Loc loc, Type type, Type to, Expression e1)
927 {
928 UnionExp ue = void;
929 Type tb = to.toBasetype();
930 Type typeb = type.toBasetype();
931 //printf("Cast(type = %s, to = %s, e1 = %s)\n", type.toChars(), to.toChars(), e1.toChars());
932 //printf("\te1.type = %s\n", e1.type.toChars());
933 if (e1.type.equals(type) && type.equals(to))
934 {
935 emplaceExp!(UnionExp)(&ue, e1);
936 return ue;
937 }
938 if (e1.op == EXP.vector && (cast(TypeVector)e1.type).basetype.equals(type) && type.equals(to))
939 {
940 Expression ex = e1.isVectorExp().e1;
941 emplaceExp!(UnionExp)(&ue, ex);
942 return ue;
943 }
944 if (e1.type.toBasetype.equals(type) && type.equals(to))
945 {
946 emplaceExp!(UnionExp)(&ue, e1);
947 ue.exp().type = type;
948 return ue;
949 }
950 if (e1.type.implicitConvTo(to) >= MATCH.constant || to.implicitConvTo(e1.type) >= MATCH.constant)
951 {
952 goto L1;
953 }
954 // Allow covariant converions of delegates
955 // (Perhaps implicit conversion from pure to impure should be a MATCH.constant,
956 // then we wouldn't need this extra check.)
957 if (e1.type.toBasetype().ty == Tdelegate && e1.type.implicitConvTo(to) == MATCH.convert)
958 {
959 goto L1;
960 }
961 /* Allow casting from one string type to another
962 */
963 if (e1.op == EXP.string_)
964 {
965 if (tb.ty == Tarray && typeb.ty == Tarray && tb.nextOf().size() == typeb.nextOf().size())
966 {
967 goto L1;
968 }
969 }
970 if (e1.op == EXP.arrayLiteral && typeb == tb)
971 {
972 L1:
973 Expression ex = expType(to, e1);
974 emplaceExp!(UnionExp)(&ue, ex);
975 return ue;
976 }
977 if (e1.isConst() != 1)
978 {
979 cantExp(ue);
980 }
981 else if (tb.ty == Tbool)
982 {
983 const opt = e1.toBool();
984 if (opt.isEmpty())
985 {
986 cantExp(ue);
987 return ue;
988 }
989
990 emplaceExp!(IntegerExp)(&ue, loc, opt.get(), type);
991 }
992 else if (type.isintegral())
993 {
994 if (e1.type.isfloating())
995 {
996 dinteger_t result;
997 real_t r = e1.toReal();
998 switch (typeb.ty)
999 {
1000 case Tint8:
1001 result = cast(byte)cast(sinteger_t)r;
1002 break;
1003 case Tchar:
1004 case Tuns8:
1005 result = cast(ubyte)cast(dinteger_t)r;
1006 break;
1007 case Tint16:
1008 result = cast(short)cast(sinteger_t)r;
1009 break;
1010 case Twchar:
1011 case Tuns16:
1012 result = cast(ushort)cast(dinteger_t)r;
1013 break;
1014 case Tint32:
1015 result = cast(int)r;
1016 break;
1017 case Tdchar:
1018 case Tuns32:
1019 result = cast(uint)r;
1020 break;
1021 case Tint64:
1022 result = cast(long)r;
1023 break;
1024 case Tuns64:
1025 result = cast(ulong)r;
1026 break;
1027 default:
1028 assert(0);
1029 }
1030 emplaceExp!(IntegerExp)(&ue, loc, result, type);
1031 }
1032 else if (type.isunsigned())
1033 emplaceExp!(IntegerExp)(&ue, loc, e1.toUInteger(), type);
1034 else
1035 emplaceExp!(IntegerExp)(&ue, loc, e1.toInteger(), type);
1036 }
1037 else if (tb.isreal())
1038 {
1039 real_t value = e1.toReal();
1040 emplaceExp!(RealExp)(&ue, loc, value, type);
1041 }
1042 else if (tb.isimaginary())
1043 {
1044 real_t value = e1.toImaginary();
1045 emplaceExp!(RealExp)(&ue, loc, value, type);
1046 }
1047 else if (tb.iscomplex())
1048 {
1049 complex_t value = e1.toComplex();
1050 emplaceExp!(ComplexExp)(&ue, loc, value, type);
1051 }
1052 else if (tb.isscalar())
1053 {
1054 emplaceExp!(IntegerExp)(&ue, loc, e1.toInteger(), type);
1055 }
1056 else if (tb.ty == Tvoid)
1057 {
1058 cantExp(ue);
1059 }
1060 else if (tb.ty == Tstruct && e1.op == EXP.int64)
1061 {
1062 // Struct = 0;
1063 StructDeclaration sd = tb.toDsymbol(null).isStructDeclaration();
1064 assert(sd);
1065 auto elements = new Expressions();
1066 for (size_t i = 0; i < sd.fields.length; i++)
1067 {
1068 VarDeclaration v = sd.fields[i];
1069 UnionExp zero;
1070 emplaceExp!(IntegerExp)(&zero, 0);
1071 ue = Cast(loc, v.type, v.type, zero.exp());
1072 if (ue.exp().op == EXP.cantExpression)
1073 return ue;
1074 elements.push(ue.exp().copy());
1075 }
1076 emplaceExp!(StructLiteralExp)(&ue, loc, sd, elements);
1077 ue.exp().type = type;
1078 }
1079 else
1080 {
1081 if (type != Type.terror)
1082 {
1083 // have to change to internal compiler error
1084 // all invalid casts should be handled already in Expression::castTo().
1085 error(loc, "cannot cast `%s` to `%s`", e1.type.toChars(), type.toChars());
1086 }
1087 emplaceExp!(ErrorExp)(&ue);
1088 }
1089 return ue;
1090 }
1091
1092 UnionExp ArrayLength(Type type, Expression e1)
1093 {
1094 UnionExp ue = void;
1095 Loc loc = e1.loc;
1096 if (StringExp es1 = e1.isStringExp())
1097 {
1098 emplaceExp!(IntegerExp)(&ue, loc, es1.len, type);
1099 }
1100 else if (ArrayLiteralExp ale = e1.isArrayLiteralExp())
1101 {
1102 size_t dim = ale.elements ? ale.elements.length : 0;
1103 emplaceExp!(IntegerExp)(&ue, loc, dim, type);
1104 }
1105 else if (AssocArrayLiteralExp ale = e1.isAssocArrayLiteralExp)
1106 {
1107 size_t dim = ale.keys.length;
1108 emplaceExp!(IntegerExp)(&ue, loc, dim, type);
1109 }
1110 else if (e1.type.toBasetype().ty == Tsarray)
1111 {
1112 Expression e = (cast(TypeSArray)e1.type.toBasetype()).dim;
1113 emplaceExp!(UnionExp)(&ue, e);
1114 }
1115 else if (e1.isNullExp())
1116 {
1117 emplaceExp!(IntegerExp)(&ue, loc, 0, type);
1118 }
1119 else
1120 cantExp(ue);
1121 return ue;
1122 }
1123
1124 /* Also return EXP.cantExpression if this fails
1125 */
1126 UnionExp Index(Type type, Expression e1, Expression e2, bool indexIsInBounds)
1127 {
1128 UnionExp ue = void;
1129 Loc loc = e1.loc;
1130 //printf("Index(e1 = %s, e2 = %s)\n", e1.toChars(), e2.toChars());
1131 assert(e1.type);
1132 if (e1.op == EXP.string_ && e2.op == EXP.int64)
1133 {
1134 StringExp es1 = e1.isStringExp();
1135 uinteger_t i = e2.toInteger();
1136 if (i >= es1.len)
1137 {
1138 e1.error("string index %llu is out of bounds `[0 .. %llu]`", i, cast(ulong)es1.len);
1139 emplaceExp!(ErrorExp)(&ue);
1140 }
1141 else
1142 {
1143 emplaceExp!(IntegerExp)(&ue, loc, es1.getCodeUnit(cast(size_t) i), type);
1144 }
1145 }
1146 else if (e1.type.toBasetype().ty == Tsarray && e2.op == EXP.int64)
1147 {
1148 TypeSArray tsa = cast(TypeSArray)e1.type.toBasetype();
1149 uinteger_t length = tsa.dim.toInteger();
1150 uinteger_t i = e2.toInteger();
1151 if (i >= length && (e1.op == EXP.arrayLiteral || !indexIsInBounds))
1152 {
1153 // C code only checks bounds if an ArrayLiteralExp
1154 e1.error("array index %llu is out of bounds `%s[0 .. %llu]`", i, e1.toChars(), length);
1155 emplaceExp!(ErrorExp)(&ue);
1156 }
1157 else if (ArrayLiteralExp ale = e1.isArrayLiteralExp())
1158 {
1159 auto e = ale[cast(size_t)i];
1160 e.type = type;
1161 e.loc = loc;
1162 if (hasSideEffect(e))
1163 cantExp(ue);
1164 else
1165 emplaceExp!(UnionExp)(&ue, e);
1166 }
1167 else
1168 cantExp(ue);
1169 }
1170 else if (e1.type.toBasetype().ty == Tarray && e2.op == EXP.int64)
1171 {
1172 uinteger_t i = e2.toInteger();
1173 if (ArrayLiteralExp ale = e1.isArrayLiteralExp())
1174 {
1175 if (i >= ale.elements.length)
1176 {
1177 e1.error("array index %llu is out of bounds `%s[0 .. %llu]`", i, e1.toChars(), cast(ulong) ale.elements.length);
1178 emplaceExp!(ErrorExp)(&ue);
1179 }
1180 else
1181 {
1182 auto e = ale[cast(size_t)i];
1183 e.type = type;
1184 e.loc = loc;
1185 if (hasSideEffect(e))
1186 cantExp(ue);
1187 else
1188 emplaceExp!(UnionExp)(&ue, e);
1189 }
1190 }
1191 else
1192 cantExp(ue);
1193 }
1194 else if (AssocArrayLiteralExp ae = e1.isAssocArrayLiteralExp())
1195 {
1196 /* Search the keys backwards, in case there are duplicate keys
1197 */
1198 for (size_t i = ae.keys.length; i;)
1199 {
1200 i--;
1201 Expression ekey = (*ae.keys)[i];
1202 ue = Equal(EXP.equal, loc, Type.tbool, ekey, e2);
1203 if (CTFEExp.isCantExp(ue.exp()))
1204 return ue;
1205 if (ue.exp().toBool().hasValue(true))
1206 {
1207 Expression e = (*ae.values)[i];
1208 e.type = type;
1209 e.loc = loc;
1210 if (hasSideEffect(e))
1211 cantExp(ue);
1212 else
1213 emplaceExp!(UnionExp)(&ue, e);
1214 return ue;
1215 }
1216 }
1217 cantExp(ue);
1218 }
1219 else
1220 cantExp(ue);
1221 return ue;
1222 }
1223
1224 /* Also return EXP.cantExpression if this fails
1225 */
1226 UnionExp Slice(Type type, Expression e1, Expression lwr, Expression upr)
1227 {
1228 UnionExp ue = void;
1229 Loc loc = e1.loc;
1230 static if (LOG)
1231 {
1232 printf("Slice()\n");
1233 if (lwr)
1234 {
1235 printf("\te1 = %s\n", e1.toChars());
1236 printf("\tlwr = %s\n", lwr.toChars());
1237 printf("\tupr = %s\n", upr.toChars());
1238 }
1239 }
1240
1241 if (!lwr)
1242 {
1243 if (e1.op == EXP.string_)
1244 emplaceExp(&ue, e1);
1245 else
1246 cantExp(ue);
1247 }
1248 else if (e1.op == EXP.string_ && lwr.op == EXP.int64 && upr.op == EXP.int64)
1249 {
1250 StringExp es1 = e1.isStringExp();
1251 const uinteger_t ilwr = lwr.toInteger();
1252 const uinteger_t iupr = upr.toInteger();
1253 if (sliceBoundsCheck(0, es1.len, ilwr, iupr))
1254 cantExp(ue); // https://issues.dlang.org/show_bug.cgi?id=18115
1255 else
1256 {
1257 const len = cast(size_t)(iupr - ilwr);
1258 const sz = es1.sz;
1259 void* s = mem.xmalloc(len * sz);
1260 const data1 = es1.peekData();
1261 memcpy(s, data1.ptr + ilwr * sz, len * sz);
1262 emplaceExp!(StringExp)(&ue, loc, s[0 .. len * sz], len, sz, es1.postfix);
1263 StringExp es = ue.exp().isStringExp();
1264 es.committed = es1.committed;
1265 es.type = type;
1266 }
1267 }
1268 else if (e1.op == EXP.arrayLiteral && lwr.op == EXP.int64 && upr.op == EXP.int64 && !hasSideEffect(e1))
1269 {
1270 ArrayLiteralExp es1 = e1.isArrayLiteralExp();
1271 const uinteger_t ilwr = lwr.toInteger();
1272 const uinteger_t iupr = upr.toInteger();
1273 if (sliceBoundsCheck(0, es1.elements.length, ilwr, iupr))
1274 cantExp(ue);
1275 else
1276 {
1277 auto elements = new Expressions(cast(size_t)(iupr - ilwr));
1278 memcpy(elements.tdata(), es1.elements.tdata() + ilwr, cast(size_t)(iupr - ilwr) * ((*es1.elements)[0]).sizeof);
1279 emplaceExp!(ArrayLiteralExp)(&ue, e1.loc, type, elements);
1280 }
1281 }
1282 else
1283 cantExp(ue);
1284 return ue;
1285 }
1286
1287 /* Check whether slice `[newlwr .. newupr]` is in the range `[lwr .. upr]`
1288 */
1289 bool sliceBoundsCheck(uinteger_t lwr, uinteger_t upr, uinteger_t newlwr, uinteger_t newupr) pure
1290 {
1291 assert(lwr <= upr);
1292 return !(newlwr <= newupr &&
1293 lwr <= newlwr &&
1294 newupr <= upr);
1295 }
1296
1297 /* Set a slice of char/integer array literal 'existingAE' from a string 'newval'.
1298 * existingAE[firstIndex..firstIndex+newval.length] = newval.
1299 */
1300 void sliceAssignArrayLiteralFromString(ArrayLiteralExp existingAE, const StringExp newval, size_t firstIndex)
1301 {
1302 const len = newval.len;
1303 Type elemType = existingAE.type.nextOf();
1304 foreach (j; 0 .. len)
1305 {
1306 const val = newval.getCodeUnit(j);
1307 (*existingAE.elements)[j + firstIndex] = new IntegerExp(newval.loc, val, elemType);
1308 }
1309 }
1310
1311 /* Set a slice of string 'existingSE' from a char array literal 'newae'.
1312 * existingSE[firstIndex..firstIndex+newae.length] = newae.
1313 */
1314 void sliceAssignStringFromArrayLiteral(StringExp existingSE, ArrayLiteralExp newae, size_t firstIndex)
1315 {
1316 assert(existingSE.ownedByCtfe != OwnedBy.code);
1317 foreach (j; 0 .. newae.elements.length)
1318 {
1319 existingSE.setCodeUnit(firstIndex + j, cast(dchar)newae[j].toInteger());
1320 }
1321 }
1322
1323 /* Set a slice of string 'existingSE' from a string 'newstr'.
1324 * existingSE[firstIndex..firstIndex+newstr.length] = newstr.
1325 */
1326 void sliceAssignStringFromString(StringExp existingSE, const StringExp newstr, size_t firstIndex)
1327 {
1328 assert(existingSE.ownedByCtfe != OwnedBy.code);
1329 size_t sz = existingSE.sz;
1330 assert(sz == newstr.sz);
1331 auto data1 = existingSE.borrowData();
1332 const data2 = newstr.peekData();
1333 memcpy(data1.ptr + firstIndex * sz, data2.ptr, data2.length);
1334 }
1335
1336 /* Compare a string slice with another string slice.
1337 * Conceptually equivalent to memcmp( se1[lo1..lo1+len], se2[lo2..lo2+len])
1338 */
1339 int sliceCmpStringWithString(const StringExp se1, const StringExp se2, size_t lo1, size_t lo2, size_t len)
1340 {
1341 size_t sz = se1.sz;
1342 assert(sz == se2.sz);
1343 const data1 = se1.peekData();
1344 const data2 = se2.peekData();
1345 return memcmp(data1.ptr + sz * lo1, data2.ptr + sz * lo2, sz * len);
1346 }
1347
1348 /* Compare a string slice with an array literal slice
1349 * Conceptually equivalent to memcmp( se1[lo1..lo1+len], ae2[lo2..lo2+len])
1350 */
1351 int sliceCmpStringWithArray(const StringExp se1, ArrayLiteralExp ae2, size_t lo1, size_t lo2, size_t len)
1352 {
1353 foreach (j; 0 .. len)
1354 {
1355 const val2 = cast(dchar)ae2[j + lo2].toInteger();
1356 const val1 = se1.getCodeUnit(j + lo1);
1357 const int c = val1 - val2;
1358 if (c)
1359 return c;
1360 }
1361 return 0;
1362 }
1363
1364 /** Copy element `Expressions` in the parameters when they're `ArrayLiteralExp`s.
1365 * Params:
1366 * e1 = If it's ArrayLiteralExp, its `elements` will be copied.
1367 * Otherwise, `e1` itself will be pushed into the new `Expressions`.
1368 * e2 = If it's not `null`, it will be pushed/appended to the new
1369 * `Expressions` by the same way with `e1`.
1370 * Returns:
1371 * Newly allocated `Expressions`. Note that it points to the original
1372 * `Expression` values in e1 and e2.
1373 */
1374 private Expressions* copyElements(Expression e1, Expression e2 = null)
1375 {
1376 auto elems = new Expressions();
1377
1378 void append(ArrayLiteralExp ale)
1379 {
1380 if (!ale.elements)
1381 return;
1382 auto d = elems.length;
1383 elems.append(ale.elements);
1384 foreach (ref el; (*elems)[d .. elems.length])
1385 {
1386 if (!el)
1387 el = ale.basis;
1388 }
1389 }
1390
1391 if (auto ale = e1.isArrayLiteralExp())
1392 append(ale);
1393 else
1394 elems.push(e1);
1395
1396 if (e2)
1397 {
1398 if (auto ale = e2.isArrayLiteralExp())
1399 append(ale);
1400 else
1401 elems.push(e2);
1402 }
1403
1404 return elems;
1405 }
1406
1407 /* Also return EXP.cantExpression if this fails
1408 */
1409 UnionExp Cat(const ref Loc loc, Type type, Expression e1, Expression e2)
1410 {
1411 UnionExp ue = void;
1412 Expression e = CTFEExp.cantexp;
1413 Type t;
1414 Type t1 = e1.type.toBasetype();
1415 Type t2 = e2.type.toBasetype();
1416 //printf("Cat(e1 = %s, e2 = %s)\n", e1.toChars(), e2.toChars());
1417 //printf("\tt1 = %s, t2 = %s, type = %s\n", t1.toChars(), t2.toChars(), type.toChars());
1418
1419 /* e is the non-null operand, t is the type of the null operand
1420 */
1421 UnionExp catNull(Expression e, Type t)
1422 {
1423 Type tn = e.type.toBasetype();
1424 if (tn.ty.isSomeChar)
1425 {
1426 // Create a StringExp
1427 if (t.nextOf())
1428 t = t.nextOf().toBasetype();
1429 const sz = cast(ubyte)t.size();
1430 dinteger_t v = e.toInteger();
1431 const len = (t.ty == tn.ty) ? 1 : utf_codeLength(sz, cast(dchar)v);
1432 void* s = mem.xmalloc(len * sz);
1433 if (t.ty == tn.ty)
1434 Port.valcpy(s, v, sz);
1435 else
1436 utf_encode(sz, s, cast(dchar)v);
1437 emplaceExp!(StringExp)(&ue, loc, s[0 .. len * sz], len, sz);
1438 StringExp es = ue.exp().isStringExp();
1439 es.type = type;
1440 es.committed = 1;
1441 }
1442 else
1443 {
1444 // Create an ArrayLiteralExp
1445 auto elements = new Expressions();
1446 elements.push(e);
1447 emplaceExp!(ArrayLiteralExp)(&ue, e.loc, type, elements);
1448 }
1449 assert(ue.exp().type);
1450 return ue;
1451 }
1452
1453 if (e1.op == EXP.null_ && (e2.op == EXP.int64 || e2.op == EXP.structLiteral))
1454 {
1455 return catNull(e2, t1);
1456 }
1457 else if ((e1.op == EXP.int64 || e1.op == EXP.structLiteral) && e2.op == EXP.null_)
1458 {
1459 return catNull(e1, t2);
1460 }
1461 else if (e1.op == EXP.null_ && e2.op == EXP.null_)
1462 {
1463 if (type == e1.type)
1464 {
1465 // Handle null ~= null
1466 if (t1.ty == Tarray && t2 == t1.nextOf())
1467 {
1468 emplaceExp!(ArrayLiteralExp)(&ue, e1.loc, type, e2);
1469 assert(ue.exp().type);
1470 return ue;
1471 }
1472 else
1473 {
1474 emplaceExp!(UnionExp)(&ue, e1);
1475 assert(ue.exp().type);
1476 return ue;
1477 }
1478 }
1479 if (type == e2.type)
1480 {
1481 emplaceExp!(UnionExp)(&ue, e2);
1482 assert(ue.exp().type);
1483 return ue;
1484 }
1485 emplaceExp!(NullExp)(&ue, e1.loc, type);
1486 assert(ue.exp().type);
1487 return ue;
1488 }
1489 else if (e1.op == EXP.string_ && e2.op == EXP.string_)
1490 {
1491 // Concatenate the strings
1492 StringExp es1 = e1.isStringExp();
1493 StringExp es2 = e2.isStringExp();
1494 size_t len = es1.len + es2.len;
1495 ubyte sz = es1.sz;
1496 if (sz != es2.sz)
1497 {
1498 /* Can happen with:
1499 * auto s = "foo"d ~ "bar"c;
1500 */
1501 assert(global.errors);
1502 cantExp(ue);
1503 assert(ue.exp().type);
1504 return ue;
1505 }
1506 void* s = mem.xmalloc(len * sz);
1507 const data1 = es1.peekData();
1508 const data2 = es2.peekData();
1509 memcpy(cast(char*)s, data1.ptr, es1.len * sz);
1510 memcpy(cast(char*)s + es1.len * sz, data2.ptr, es2.len * sz);
1511 emplaceExp!(StringExp)(&ue, loc, s[0 .. len * sz], len, sz);
1512 StringExp es = ue.exp().isStringExp();
1513 es.committed = es1.committed | es2.committed;
1514 es.type = type;
1515 assert(ue.exp().type);
1516 return ue;
1517 }
1518 else if (e2.op == EXP.string_ && e1.op == EXP.arrayLiteral && t1.nextOf().isintegral())
1519 {
1520 // [chars] ~ string --> [chars]
1521 StringExp es = e2.isStringExp();
1522 ArrayLiteralExp ea = e1.isArrayLiteralExp();
1523 size_t len = es.len + ea.elements.length;
1524 auto elems = new Expressions(len);
1525 for (size_t i = 0; i < ea.elements.length; ++i)
1526 {
1527 (*elems)[i] = ea[i];
1528 }
1529 emplaceExp!(ArrayLiteralExp)(&ue, e1.loc, type, elems);
1530 ArrayLiteralExp dest = ue.exp().isArrayLiteralExp();
1531 sliceAssignArrayLiteralFromString(dest, es, ea.elements.length);
1532 assert(ue.exp().type);
1533 return ue;
1534 }
1535 else if (e1.op == EXP.string_ && e2.op == EXP.arrayLiteral && t2.nextOf().isintegral())
1536 {
1537 // string ~ [chars] --> [chars]
1538 StringExp es = e1.isStringExp();
1539 ArrayLiteralExp ea = e2.isArrayLiteralExp();
1540 size_t len = es.len + ea.elements.length;
1541 auto elems = new Expressions(len);
1542 for (size_t i = 0; i < ea.elements.length; ++i)
1543 {
1544 (*elems)[es.len + i] = ea[i];
1545 }
1546 emplaceExp!(ArrayLiteralExp)(&ue, e1.loc, type, elems);
1547 ArrayLiteralExp dest = ue.exp().isArrayLiteralExp();
1548 sliceAssignArrayLiteralFromString(dest, es, 0);
1549 assert(ue.exp().type);
1550 return ue;
1551 }
1552 else if (e1.op == EXP.string_ && e2.op == EXP.int64)
1553 {
1554 // string ~ char --> string
1555 StringExp es1 = e1.isStringExp();
1556 StringExp es;
1557 const sz = es1.sz;
1558 dinteger_t v = e2.toInteger();
1559 // Is it a concatenation of homogenous types?
1560 // (char[] ~ char, wchar[]~wchar, or dchar[]~dchar)
1561 bool homoConcat = (sz == t2.size());
1562 const len = es1.len + (homoConcat ? 1 : utf_codeLength(sz, cast(dchar)v));
1563 void* s = mem.xmalloc(len * sz);
1564 const data1 = es1.peekData();
1565 memcpy(s, data1.ptr, data1.length);
1566 if (homoConcat)
1567 Port.valcpy(cast(char*)s + (sz * es1.len), v, sz);
1568 else
1569 utf_encode(sz, cast(char*)s + (sz * es1.len), cast(dchar)v);
1570 emplaceExp!(StringExp)(&ue, loc, s[0 .. len * sz], len, sz);
1571 es = ue.exp().isStringExp();
1572 es.committed = es1.committed;
1573 es.type = type;
1574 assert(ue.exp().type);
1575 return ue;
1576 }
1577 else if (e1.op == EXP.int64 && e2.op == EXP.string_)
1578 {
1579 // [w|d]?char ~ string --> string
1580 // We assume that we only ever prepend one char of the same type
1581 // (wchar,dchar) as the string's characters.
1582 StringExp es2 = e2.isStringExp();
1583 const len = 1 + es2.len;
1584 const sz = es2.sz;
1585 dinteger_t v = e1.toInteger();
1586 void* s = mem.xmalloc(len * sz);
1587 Port.valcpy(cast(char*)s, v, sz);
1588 const data2 = es2.peekData();
1589 memcpy(cast(char*)s + sz, data2.ptr, data2.length);
1590 emplaceExp!(StringExp)(&ue, loc, s[0 .. len * sz], len, sz);
1591 StringExp es = ue.exp().isStringExp();
1592 es.sz = sz;
1593 es.committed = es2.committed;
1594 es.type = type;
1595 assert(ue.exp().type);
1596 return ue;
1597 }
1598 else if (e1.op == EXP.arrayLiteral && e2.op == EXP.arrayLiteral && t1.nextOf().equals(t2.nextOf()))
1599 {
1600 // Concatenate the arrays
1601 auto elems = copyElements(e1, e2);
1602
1603 emplaceExp!(ArrayLiteralExp)(&ue, e1.loc, cast(Type)null, elems);
1604
1605 e = ue.exp();
1606 if (type.toBasetype().ty == Tsarray)
1607 {
1608 e.type = t1.nextOf().sarrayOf(elems.length);
1609 }
1610 else
1611 e.type = type;
1612 assert(ue.exp().type);
1613 return ue;
1614 }
1615 else if (e1.op == EXP.arrayLiteral && e2.op == EXP.null_ && t1.nextOf().equals(t2.nextOf()))
1616 {
1617 e = e1;
1618 goto L3;
1619 }
1620 else if (e1.op == EXP.null_ && e2.op == EXP.arrayLiteral && t1.nextOf().equals(t2.nextOf()))
1621 {
1622 e = e2;
1623 L3:
1624 // Concatenate the array with null
1625 auto elems = copyElements(e);
1626
1627 emplaceExp!(ArrayLiteralExp)(&ue, e.loc, cast(Type)null, elems);
1628
1629 e = ue.exp();
1630 if (type.toBasetype().ty == Tsarray)
1631 {
1632 e.type = t1.nextOf().sarrayOf(elems.length);
1633 }
1634 else
1635 e.type = type;
1636 assert(ue.exp().type);
1637 return ue;
1638 }
1639 else if ((e1.op == EXP.arrayLiteral || e1.op == EXP.null_) && e1.type.toBasetype().nextOf() && e1.type.toBasetype().nextOf().equals(e2.type))
1640 {
1641 auto elems = (e1.op == EXP.arrayLiteral)
1642 ? copyElements(e1) : new Expressions();
1643 elems.push(e2);
1644
1645 emplaceExp!(ArrayLiteralExp)(&ue, loc, cast(Type)null, elems);
1646
1647 e = ue.exp();
1648 if (type.toBasetype().ty == Tsarray)
1649 {
1650 e.type = e2.type.sarrayOf(elems.length);
1651 }
1652 else
1653 e.type = type;
1654 assert(ue.exp().type);
1655 return ue;
1656 }
1657 else if (e2.op == EXP.arrayLiteral && e2.type.toBasetype().nextOf().equals(e1.type))
1658 {
1659 auto elems = copyElements(e1, e2);
1660
1661 emplaceExp!(ArrayLiteralExp)(&ue, loc, cast(Type)null, elems);
1662
1663 e = ue.exp();
1664 if (type.toBasetype().ty == Tsarray)
1665 {
1666 e.type = e1.type.sarrayOf(elems.length);
1667 }
1668 else
1669 e.type = type;
1670 assert(ue.exp().type);
1671 return ue;
1672 }
1673 else if (e1.op == EXP.null_ && e2.op == EXP.string_)
1674 {
1675 t = e1.type;
1676 e = e2;
1677 goto L1;
1678 }
1679 else if (e1.op == EXP.string_ && e2.op == EXP.null_)
1680 {
1681 e = e1;
1682 t = e2.type;
1683 L1:
1684 Type tb = t.toBasetype();
1685 if (tb.ty == Tarray && tb.nextOf().equivalent(e.type))
1686 {
1687 auto expressions = new Expressions();
1688 expressions.push(e);
1689 emplaceExp!(ArrayLiteralExp)(&ue, loc, t, expressions);
1690 e = ue.exp();
1691 }
1692 else
1693 {
1694 emplaceExp!(UnionExp)(&ue, e);
1695 e = ue.exp();
1696 }
1697 if (!e.type.equals(type))
1698 {
1699 StringExp se = e.copy().isStringExp();
1700 e = se.castTo(null, type);
1701 emplaceExp!(UnionExp)(&ue, e);
1702 e = ue.exp();
1703 }
1704 }
1705 else
1706 cantExp(ue);
1707 assert(ue.exp().type);
1708 return ue;
1709 }
1710
1711 UnionExp Ptr(Type type, Expression e1)
1712 {
1713 //printf("Ptr(e1 = %s)\n", e1.toChars());
1714 UnionExp ue = void;
1715 if (AddExp ae = e1.isAddExp())
1716 {
1717 if (AddrExp ade = ae.e1.isAddrExp())
1718 {
1719 if (ae.e2.op == EXP.int64)
1720 if (StructLiteralExp se = ade.e1.isStructLiteralExp())
1721 {
1722 uint offset = cast(uint)ae.e2.toInteger();
1723 Expression e = se.getField(type, offset);
1724 if (e)
1725 {
1726 emplaceExp!(UnionExp)(&ue, e);
1727 return ue;
1728 }
1729 }
1730 }
1731 }
1732 cantExp(ue);
1733 return ue;
1734 }
Mirror of the offical gcc git repository hosted at gcc.gnu.org