/
e2ir.d
7123 lines (6361 loc) · 233 KB
/
e2ir.d
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/**
* Converts expressions to Intermediate Representation (IR) for the backend.
*
* Copyright: Copyright (C) 1999-2024 by The D Language Foundation, All Rights Reserved
* Authors: $(LINK2 https://www.digitalmars.com, Walter Bright)
* License: $(LINK2 https://www.boost.org/LICENSE_1_0.txt, Boost License 1.0)
* Source: $(LINK2 https://github.com/dlang/dmd/blob/master/src/e2ir.d, _e2ir.d)
* Documentation: https://dlang.org/phobos/dmd_e2ir.html
* Coverage: https://codecov.io/gh/dlang/dmd/src/master/src/dmd/e2ir.d
*/
module dmd.e2ir;
import core.stdc.stdio;
import core.stdc.stddef;
import core.stdc.string;
import core.stdc.time;
import dmd.root.array;
import dmd.root.ctfloat;
import dmd.root.rmem;
import dmd.rootobject;
import dmd.root.stringtable;
import dmd.aggregate;
import dmd.arraytypes;
import dmd.astenums;
import dmd.attrib;
import dmd.canthrow;
import dmd.ctfeexpr;
import dmd.dclass;
import dmd.declaration;
import dmd.denum;
import dmd.dmdparams;
import dmd.dmodule;
import dmd.dscope;
import dmd.dstruct;
import dmd.dsymbol;
import dmd.dtemplate;
import dmd.expression;
import dmd.func;
import dmd.glue;
import dmd.hdrgen;
import dmd.id;
import dmd.init;
import dmd.location;
import dmd.mtype;
import dmd.objc_glue;
import dmd.printast;
import dmd.s2ir;
import dmd.sideeffect;
import dmd.statement;
import dmd.target;
import dmd.tocsym;
import dmd.toctype;
import dmd.toir;
import dmd.tokens;
import dmd.toobj;
import dmd.typinf;
import dmd.typesem;
import dmd.visitor;
import dmd.backend.cc;
import dmd.backend.cdef;
import dmd.backend.cgcv;
import dmd.backend.code;
import dmd.backend.code_x86;
import dmd.backend.cv4;
import dmd.backend.dt;
import dmd.backend.el;
import dmd.backend.global;
import dmd.backend.obj;
import dmd.backend.oper;
import dmd.backend.rtlsym;
import dmd.backend.symtab;
import dmd.backend.ty;
import dmd.backend.type;
alias Elems = Array!(elem *);
import dmd.backend.util2 : mem_malloc2;
private int registerSize() { return _tysize[TYnptr]; }
/*****
* If variable var is a value that will actually be passed as a reference
* Params:
* var = parameter variable
* Returns:
* true if actually implicitly passed by reference
*/
bool ISX64REF(Declaration var)
{
if (var.isReference())
{
return false; // it's not a value
}
if (var.isParameter())
{
if (target.os == Target.OS.Windows && target.isX86_64)
{
/* Use Microsoft C++ ABI
* https://docs.microsoft.com/en-us/cpp/build/x64-calling-convention?view=msvc-170#parameter-passing
* but watch out because the spec doesn't mention copy construction
*/
return var.type.size(Loc.initial) > registerSize
|| (var.storage_class & STC.lazy_)
|| (var.type.isTypeStruct() && var.type.isTypeStruct().sym.hasCopyConstruction());
}
else if (target.os & Target.OS.Posix)
{
return !(var.storage_class & STC.lazy_) && var.type.isTypeStruct() && !var.type.isTypeStruct().sym.isPOD();
}
}
return false;
}
/* If variable exp of type typ is a reference due to x64 calling conventions
*/
bool ISX64REF(ref IRState irs, Expression exp)
{
if (irs.target.os == Target.OS.Windows && irs.target.isX86_64)
{
return exp.type.size(Loc.initial) > registerSize
|| (exp.type.isTypeStruct() && exp.type.isTypeStruct().sym.hasCopyConstruction());
}
else if (irs.target.os & Target.OS.Posix)
{
return exp.type.isTypeStruct() && !exp.type.isTypeStruct().sym.isPOD();
}
return false;
}
/**************************************************
* Generate a copy from e2 to e1.
* Params:
* e1 = lvalue
* e2 = rvalue
* t = value type
* tx = if !null, then t converted to C type
* Returns:
* generated elem
*/
elem* elAssign(elem* e1, elem* e2, Type t, type* tx)
{
//printf("e1:\n"); elem_print(e1);
//printf("e2:\n"); elem_print(e2);
//if (t) printf("t: %s\n", t.toChars());
elem *e = el_bin(OPeq, e2.Ety, e1, e2);
switch (tybasic(e2.Ety))
{
case TYarray:
e.Ejty = e.Ety = TYstruct;
goto case TYstruct;
case TYstruct:
e.Eoper = OPstreq;
if (!tx)
tx = Type_toCtype(t);
//printf("tx:\n"); type_print(tx);
e.ET = tx;
// if (type_zeroCopy(tx))
// e.Eoper = OPcomma;
break;
default:
break;
}
return e;
}
/*************************************************
* Determine if zero bits need to be copied for this backend type
* Params:
* t = backend type
* Returns:
* true if 0 bits
*/
bool type_zeroCopy(type* t)
{
return type_size(t) == 0 ||
(tybasic(t.Tty) == TYstruct &&
(t.Ttag.Stype.Ttag.Sstruct.Sflags & STR0size));
}
/*******************************************************
* Write read-only string to object file, create a local symbol for it.
* Makes a copy of str's contents, does not keep a reference to it.
* Params:
* str = string
* len = number of code units in string
* sz = number of bytes per code unit
* Returns:
* Symbol
*/
Symbol *toStringSymbol(const(char)* str, size_t len, size_t sz)
{
//printf("toStringSymbol() %p\n", stringTab);
auto sv = stringTab.update(str, len * sz);
if (!sv.value)
{
Symbol* si;
if (target.os == Target.OS.Windows)
{
/* This should be in the back end, but mangleToBuffer() is
* in the front end.
*/
/* The stringTab pools common strings within an object file.
* Win32 and Win64 use COMDATs to pool common strings across object files.
*/
/* VC++ uses a name mangling scheme, for example, "hello" is mangled to:
* ??_C@_05CJBACGMB@hello?$AA@
* ^ length
* ^^^^^^^^ 8 byte checksum
* But the checksum algorithm is unknown. Just invent our own.
*/
import dmd.common.outbuffer : OutBuffer;
OutBuffer buf;
buf.writestring("__");
void printHash()
{
// Replace long string with hash of that string
import dmd.common.blake3;
//only use the first 16 bytes to match the length of md5
const hash = blake3((cast(ubyte*)str)[0 .. len * sz]);
foreach (u; hash[0 .. 16])
{
ubyte u1 = u >> 4;
buf.writeByte((u1 < 10) ? u1 + '0' : u1 + 'A' - 10);
u1 = u & 0xF;
buf.writeByte((u1 < 10) ? u1 + '0' : u1 + 'A' - 10);
}
}
const mangleMinLen = 14; // mangling: "__a14_(14*2 chars)" = 6+14*2 = 34
if (len >= mangleMinLen) // long mangling for sure, use hash
printHash();
else
{
import dmd.dmangle;
scope StringExp se = new StringExp(Loc.initial, str[0 .. len], len, cast(ubyte)sz, 'c');
mangleToBuffer(se, buf); // recycle how strings are mangled for templates
if (buf.length >= 32 + 2) // long mangling, replace with hash
{
buf.setsize(2);
printHash();
}
}
si = symbol_calloc(buf[]);
si.Sclass = SC.comdat;
si.Stype = type_static_array(cast(uint)(len * sz), tstypes[TYchar]);
si.Stype.Tcount++;
type_setmangle(&si.Stype, mTYman_c);
si.Sflags |= SFLnodebug | SFLartifical;
si.Sfl = FLdata;
si.Salignment = cast(ubyte)sz;
out_readonly_comdat(si, str, cast(uint)(len * sz), cast(uint)sz);
}
else
{
si = out_string_literal(str, cast(uint)len, cast(uint)sz);
}
sv.value = si;
}
return sv.value;
}
/*******************************************************
* Turn StringExp into Symbol.
*/
Symbol *toStringSymbol(StringExp se)
{
Symbol *si;
const n = cast(int)se.numberOfCodeUnits();
if (se.sz == 1)
{
const slice = se.peekString();
si = toStringSymbol(slice.ptr, slice.length, 1);
}
else
{
auto p = cast(char *)mem.xmalloc(n * se.sz);
se.writeTo(p, false);
si = toStringSymbol(p, n, se.sz);
mem.xfree(p);
}
return si;
}
/******************************************************
* Replace call to GC allocator with call to tracing GC allocator.
* Params:
* irs = to get function from
* e = elem to modify in place
* loc = to get file/line from
*/
void toTraceGC(ref IRState irs, elem *e, const ref Loc loc)
{
static immutable RTLSYM[2][25] map =
[
[ RTLSYM.NEWCLASS, RTLSYM.TRACENEWCLASS ],
[ RTLSYM.NEWITEMT, RTLSYM.TRACENEWITEMT ],
[ RTLSYM.NEWITEMIT, RTLSYM.TRACENEWITEMIT ],
[ RTLSYM.NEWARRAYT, RTLSYM.TRACENEWARRAYT ],
[ RTLSYM.NEWARRAYIT, RTLSYM.TRACENEWARRAYIT ],
[ RTLSYM.NEWARRAYMTX, RTLSYM.TRACENEWARRAYMTX ],
[ RTLSYM.NEWARRAYMITX, RTLSYM.TRACENEWARRAYMITX ],
[ RTLSYM.CALLFINALIZER, RTLSYM.TRACECALLFINALIZER ],
[ RTLSYM.CALLINTERFACEFINALIZER, RTLSYM.TRACECALLINTERFACEFINALIZER ],
[ RTLSYM.ARRAYLITERALTX, RTLSYM.TRACEARRAYLITERALTX ],
[ RTLSYM.ASSOCARRAYLITERALTX, RTLSYM.TRACEASSOCARRAYLITERALTX ],
[ RTLSYM.ARRAYCATT, RTLSYM.TRACEARRAYCATT ],
[ RTLSYM.ARRAYCATNTX, RTLSYM.TRACEARRAYCATNTX ],
[ RTLSYM.ARRAYAPPENDCD, RTLSYM.TRACEARRAYAPPENDCD ],
[ RTLSYM.ARRAYAPPENDWD, RTLSYM.TRACEARRAYAPPENDWD ],
[ RTLSYM.ARRAYAPPENDT, RTLSYM.TRACEARRAYAPPENDT ],
[ RTLSYM.ARRAYAPPENDCTX, RTLSYM.TRACEARRAYAPPENDCTX ],
[ RTLSYM.ARRAYSETLENGTHT, RTLSYM.TRACEARRAYSETLENGTHT ],
[ RTLSYM.ARRAYSETLENGTHIT, RTLSYM.TRACEARRAYSETLENGTHIT ],
[ RTLSYM.ALLOCMEMORY, RTLSYM.TRACEALLOCMEMORY ],
];
if (irs.params.tracegc && loc.filename)
{
assert(e.Eoper == OPcall);
elem *e1 = e.EV.E1;
assert(e1.Eoper == OPvar);
auto s = e1.EV.Vsym;
/* In -dip1008 code the allocation of exceptions is no longer done by the
* gc, but by a manual reference counting mechanism implementend in druntime.
* If that is the case, then there is nothing to trace.
*/
if (s == getRtlsym(RTLSYM.NEWTHROW))
return;
foreach (ref m; map)
{
if (s == getRtlsym(m[0]))
{
e1.EV.Vsym = getRtlsym(m[1]);
e.EV.E2 = el_param(e.EV.E2, filelinefunction(irs, loc));
return;
}
}
assert(0);
}
}
/*******************************************
* Convert Expression to elem, then append destructors for any
* temporaries created in elem.
* Params:
* e = Expression to convert
* irs = context
* Returns:
* generated elem tree
*/
elem *toElemDtor(Expression e, ref IRState irs)
{
//printf("Expression.toElemDtor() %s\n", e.toChars());
/* "may" throw may actually be false if we look at a subset of
* the function. Here, the subset is `e`. If that subset is nothrow,
* we can generate much better code for the destructors for that subset,
* even if the rest of the function throws.
* If mayThrow is false, it cannot be true for some subset of the function,
* so no need to check.
* If calling canThrow() here turns out to be too expensive,
* it can be enabled only for optimized builds.
*/
const mayThrowSave = irs.mayThrow;
if (irs.mayThrow && !canThrow(e, irs.getFunc(), null))
irs.mayThrow = false;
const starti = irs.varsInScope.length;
elem* er = toElem(e, irs);
const endi = irs.varsInScope.length;
irs.mayThrow = mayThrowSave;
// Add destructors
elem* ex = appendDtors(irs, er, starti, endi);
return ex;
}
/*******************************************
* Take address of an elem.
* Accounts for e being an rvalue by assigning the rvalue
* to a temp.
* Params:
* e = elem to take address of
* t = Type of elem
* alwaysCopy = when true, always copy e to a tmp
* Returns:
* the equivalent of &e
*/
elem *addressElem(elem *e, Type t, bool alwaysCopy = false)
{
//printf("addressElem()\n");
elem **pe;
for (pe = &e; (*pe).Eoper == OPcomma; pe = &(*pe).EV.E2)
{
}
// For conditional operator, both branches need conversion.
if ((*pe).Eoper == OPcond)
{
elem *ec = (*pe).EV.E2;
ec.EV.E1 = addressElem(ec.EV.E1, t, alwaysCopy);
ec.EV.E2 = addressElem(ec.EV.E2, t, alwaysCopy);
(*pe).Ejty = (*pe).Ety = cast(ubyte)ec.EV.E1.Ety;
(*pe).ET = ec.EV.E1.ET;
e.Ety = TYnptr;
return e;
}
if (alwaysCopy || ((*pe).Eoper != OPvar && (*pe).Eoper != OPind))
{
elem *e2 = *pe;
type *tx;
// Convert to ((tmp=e2),tmp)
TY ty;
if (t && ((ty = t.toBasetype().ty) == Tstruct || ty == Tsarray))
tx = Type_toCtype(t);
else if (tybasic(e2.Ety) == TYstruct)
{
assert(t); // don't know of a case where this can be null
tx = Type_toCtype(t);
}
else
tx = type_fake(e2.Ety);
Symbol *stmp = symbol_genauto(tx);
elem *eeq = elAssign(el_var(stmp), e2, t, tx);
*pe = el_bin(OPcomma,e2.Ety,eeq,el_var(stmp));
}
tym_t typ = TYnptr;
if (e.Eoper == OPind && tybasic(e.EV.E1.Ety) == TYimmutPtr)
typ = TYimmutPtr;
e = el_una(OPaddr,typ,e);
return e;
}
/********************************
* Reset stringTab[] between object files being emitted, because the symbols are local.
*/
void clearStringTab()
{
//printf("clearStringTab()\n");
if (stringTab)
stringTab.reset(1000); // 1000 is arbitrary guess
else
{
stringTab = new StringTable!(Symbol*)();
stringTab._init(1000);
}
}
private __gshared StringTable!(Symbol*) *stringTab;
/*********************************************
* Figure out whether a data symbol should be dllimported
* Params:
* var = declaration of the symbol
* Returns:
* true if symbol should be imported from a DLL
*/
bool isDllImported(Dsymbol var)
{
if (!(target.os & Target.OS.Windows))
return false;
if (var.isImportedSymbol())
return true;
if (driverParams.symImport == SymImport.none)
return false;
if (auto vd = var.isDeclaration())
if (!vd.isDataseg() || vd.isThreadlocal())
return false;
if (var.isFuncDeclaration())
return false; // can always jump through import table
if (auto tid = var.isTypeInfoDeclaration())
{
if (builtinTypeInfo(tid.tinfo))
return true;
else if (auto ad = isAggregate(tid.type))
var = ad;
}
if (driverParams.symImport == SymImport.defaultLibsOnly)
{
auto m = var.getModule();
if (!m || !m.md)
return false;
const id = m.md.packages.length ? m.md.packages[0] : null;
if (id && id != Id.core && id != Id.std)
return false;
else if (!id && m.md.id != Id.std && m.md.id != Id.object)
return false;
}
else if (driverParams.symImport != SymImport.all)
return false;
if (auto mod = var.isModule())
return !mod.isRoot(); // non-root ModuleInfo symbol
if (var.inNonRoot())
return true; // not instantiated, and defined in non-root
if (auto ti = var.isInstantiated()) // && !defineOnDeclare(sym, false))
return !ti.needsCodegen(); // instantiated but potentially culled (needsCodegen())
if (auto vd = var.isVarDeclaration())
if (vd.storage_class & STC.extern_)
return true; // externally defined global variable
return false;
}
/*********************************************
* Generate a backend symbol for a frontend symbol
* Params:
* s = frontend symbol
* Returns:
* the backend symbol or the associated symbol in the
* import table if it is expected to be imported from a DLL
*/
Symbol* toExtSymbol(Dsymbol s)
{
if (isDllImported(s))
return toImport(s);
else
return toSymbol(s);
}
/*********************************************
* Convert Expression to backend elem.
* Params:
* e = expression tree
* irs = context
* Returns:
* backend elem tree
*/
elem* toElem(Expression e, ref IRState irs)
{
elem* visit(Expression e)
{
printf("[%s] %s: %s\n", e.loc.toChars(), EXPtoString(e.op).ptr, e.toChars());
assert(0);
}
elem* visitSymbol(SymbolExp se) // VarExp and SymOffExp
{
elem *e;
Type tb = (se.op == EXP.symbolOffset) ? se.var.type.toBasetype() : se.type.toBasetype();
long offset = (se.op == EXP.symbolOffset) ? cast(long)(cast(SymOffExp)se).offset : 0;
VarDeclaration v = se.var.isVarDeclaration();
//printf("[%s] SymbolExp.toElem('%s') %p, %s\n", se.loc.toChars(), se.toChars(), se, se.type.toChars());
//printf("\tparent = '%s'\n", se.var.parent ? se.var.parent.toChars() : "null");
if (se.op == EXP.variable && se.var.needThis())
{
irs.eSink.error(se.loc, "need `this` to access member `%s`", se.toChars());
return el_long(TYsize_t, 0);
}
/* The magic variable __ctfe is always false at runtime
*/
if (se.op == EXP.variable && v && v.ident == Id.ctfe)
{
return el_long(totym(se.type), 0);
}
if (FuncLiteralDeclaration fld = se.var.isFuncLiteralDeclaration())
{
if (fld.tok == TOK.reserved)
{
// change to non-nested
fld.tok = TOK.function_;
fld.vthis = null;
}
if (!fld.deferToObj)
{
fld.deferToObj = true;
irs.deferToObj.push(fld);
}
}
Symbol *s = toSymbol(se.var);
// VarExp generated for `__traits(initSymbol, Aggregate)`?
if (auto symDec = se.var.isSymbolDeclaration())
{
if (se.type.isTypeDArray())
{
assert(se.type == Type.tvoid.arrayOf().constOf(), se.toString());
// Generate s[0 .. Aggregate.sizeof] for non-zero initialised aggregates
// Otherwise create (null, Aggregate.sizeof)
auto ad = symDec.dsym;
auto ptr = (ad.isStructDeclaration() && ad.type.isZeroInit(Loc.initial))
? el_long(TYnptr, 0)
: el_ptr(s);
auto length = el_long(TYsize_t, ad.structsize);
auto slice = el_pair(TYdarray, length, ptr);
elem_setLoc(slice, se.loc);
return slice;
}
}
FuncDeclaration fd = null;
if (se.var.toParent2())
fd = se.var.toParent2().isFuncDeclaration();
const bool nrvo = fd && fd.isNRVO() && fd.nrvo_var == se.var;
if (nrvo)
s = fd.shidden;
if (s.Sclass == SC.auto_ || s.Sclass == SC.parameter || s.Sclass == SC.shadowreg)
{
if (fd && fd != irs.getFunc())
{
// 'var' is a variable in an enclosing function.
elem *ethis = getEthis(se.loc, irs, fd, null, se.originalScope);
ethis = el_una(OPaddr, TYnptr, ethis);
/* https://issues.dlang.org/show_bug.cgi?id=9383
* If 's' is a virtual function parameter
* placed in closure, and actually accessed from in/out
* contract, instead look at the original stack data.
*/
bool forceStackAccess = false;
if (fd.isVirtual() && (fd.fdrequire || fd.fdensure))
{
Dsymbol sx = irs.getFunc();
while (sx != fd)
{
if (sx.ident == Id.require || sx.ident == Id.ensure)
{
forceStackAccess = true;
break;
}
sx = sx.toParent2();
}
}
int soffset;
if (v && v.inClosure && !forceStackAccess)
soffset = v.offset;
else if (v && v.inAlignSection)
{
const vthisOffset = fd.vthis ? -toSymbol(fd.vthis).Soffset : 0;
ethis = el_bin(OPadd, TYnptr, ethis, el_long(TYnptr, vthisOffset + fd.salignSection.Soffset));
ethis = el_una(OPind, TYnptr, ethis);
soffset = v.offset;
}
else
{
soffset = cast(int)s.Soffset;
/* If fd is a non-static member function of a class or struct,
* then ethis isn't the frame pointer.
* ethis is the 'this' pointer to the class/struct instance.
* We must offset it.
*/
if (fd.vthis)
{
Symbol *vs = toSymbol(fd.vthis);
//printf("vs = %s, offset = x%x, %p\n", vs.Sident.ptr, cast(int)vs.Soffset, vs);
soffset -= vs.Soffset;
}
//printf("\tSoffset = x%x, sthis.Soffset = x%x\n", cast(uint)s.Soffset, cast(uint)irs.sthis.Soffset);
}
if (!nrvo)
soffset += offset;
e = el_bin(OPadd, TYnptr, ethis, el_long(TYnptr, soffset));
if (se.op == EXP.variable)
e = el_una(OPind, TYnptr, e);
if ((se.var.isReference() || ISX64REF(se.var)) && !(ISX64REF(se.var) && v && v.offset && !forceStackAccess))
e = el_una(OPind, s.Stype.Tty, e);
else if (se.op == EXP.symbolOffset && nrvo)
{
e = el_una(OPind, TYnptr, e);
e = el_bin(OPadd, e.Ety, e, el_long(TYsize_t, offset));
}
goto L1;
}
}
/* If var is a member of a closure or aligned section
*/
if (v && (v.inClosure || v.inAlignSection))
{
assert(irs.sclosure || fd.salignSection);
e = el_var(v.inClosure ? irs.sclosure : fd.salignSection);
e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, v.offset));
if (se.op == EXP.variable)
{
e = el_una(OPind, totym(se.type), e);
if (tybasic(e.Ety) == TYstruct)
e.ET = Type_toCtype(se.type);
elem_setLoc(e, se.loc);
}
if (se.var.isReference())
{
e.Ety = TYnptr;
e = el_una(OPind, s.Stype.Tty, e);
}
else if (se.op == EXP.symbolOffset && nrvo)
{
e = el_una(OPind, TYnptr, e);
e = el_bin(OPadd, e.Ety, e, el_long(TYsize_t, offset));
}
else if (se.op == EXP.symbolOffset)
{
e = el_bin(OPadd, e.Ety, e, el_long(TYsize_t, offset));
}
goto L1;
}
if (s.Sclass == SC.auto_ && s.Ssymnum == SYMIDX.max)
{
//printf("\tadding symbol %s\n", s.Sident);
symbol_add(s);
}
if (se.op == EXP.variable && isDllImported(se.var))
{
assert(se.op == EXP.variable);
if (target.os & Target.OS.Posix)
{
e = el_var(s);
}
else
{
e = el_var(toImport(se.var));
e = el_una(OPind,s.Stype.Tty,e);
}
}
else if (se.var.isReference() || ISX64REF(se.var))
{
// Out parameters are really references
e = el_var(s);
e.Ety = TYnptr;
if (se.op == EXP.variable)
e = el_una(OPind, s.Stype.Tty, e);
else if (offset)
e = el_bin(OPadd, TYnptr, e, el_long(TYsize_t, offset));
}
else if (se.op == EXP.variable)
e = el_var(s);
else
{
e = nrvo ? el_var(s) : el_ptr(s);
e = el_bin(OPadd, e.Ety, e, el_long(TYsize_t, offset));
}
L1:
if (se.op == EXP.variable)
{
if (nrvo)
{
e.Ety = TYnptr;
e = el_una(OPind, 0, e);
}
tym_t tym;
if (se.var.storage_class & STC.lazy_)
tym = TYdelegate; // Tdelegate as C type
else if (tb.ty == Tfunction)
tym = s.Stype.Tty;
else
tym = totym(se.type);
e.Ejty = cast(ubyte)(e.Ety = tym);
if (tybasic(tym) == TYstruct)
{
e.ET = Type_toCtype(se.type);
}
else if (tybasic(tym) == TYarray)
{
e.Ejty = e.Ety = TYstruct;
e.ET = Type_toCtype(se.type);
}
else if (tysimd(tym))
{
e.ET = Type_toCtype(se.type);
}
}
elem_setLoc(e,se.loc);
return e;
}
elem* visitFunc(FuncExp fe)
{
//printf("FuncExp.toElem() %s\n", fe.toChars());
FuncLiteralDeclaration fld = fe.fd;
if (fld.tok == TOK.reserved && fe.type.ty == Tpointer)
{
// change to non-nested
fld.tok = TOK.function_;
fld.vthis = null;
}
if (!fld.deferToObj)
{
fld.deferToObj = true;
irs.deferToObj.push(fld);
}
Symbol *s = toSymbol(fld);
elem *e = el_ptr(s);
if (fld.isNested())
{
elem *ethis;
// Delegate literals report isNested() even if they are in global scope,
// so we need to check that the parent is a function.
if (!fld.toParent2().isFuncDeclaration())
ethis = el_long(TYnptr, 0);
else
ethis = getEthis(fe.loc, irs, fld);
e = el_pair(TYdelegate, ethis, e);
}
elem_setLoc(e, fe.loc);
return e;
}
elem* visitDeclaration(DeclarationExp de)
{
//printf("DeclarationExp.toElem() %s\n", de.toChars());
return Dsymbol_toElem(de.declaration, irs);
}
/***************************************
*/
elem* visitTypeid(TypeidExp e)
{
//printf("TypeidExp.toElem() %s\n", e.toChars());
if (Type t = isType(e.obj))
{
elem* result = getTypeInfo(e, t, irs);
return el_bin(OPadd, result.Ety, result, el_long(TYsize_t, t.vtinfo.offset));
}
if (Expression ex = isExpression(e.obj))
{
if (auto ev = ex.isVarExp())
{
if (auto em = ev.var.isEnumMember())
ex = em.value;
}
if (auto ecr = ex.isClassReferenceExp())
{
Type t = ecr.type;
elem* result = getTypeInfo(ecr, t, irs);
return el_bin(OPadd, result.Ety, result, el_long(TYsize_t, t.vtinfo.offset));
}
auto tc = ex.type.toBasetype().isTypeClass();
assert(tc);
// generate **classptr to get the classinfo
elem* result = toElem(ex, irs);
result = el_una(OPind,TYnptr,result);
result = el_una(OPind,TYnptr,result);
// Add extra indirection for interfaces
if (tc.sym.isInterfaceDeclaration())
result = el_una(OPind,TYnptr,result);
return result;
}
assert(0);
}
/***************************************
*/
elem* visitThis(ThisExp te)
{
//printf("ThisExp.toElem()\n");
assert(irs.sthis);
elem *ethis;
if (te.var)
{
assert(te.var.parent);
FuncDeclaration fd = te.var.toParent2().isFuncDeclaration();
assert(fd);
ethis = getEthis(te.loc, irs, fd);
ethis = fixEthis2(ethis, fd);
}
else
{
ethis = el_var(irs.sthis);
ethis = fixEthis2(ethis, irs.getFunc());
}
if (te.type.ty == Tstruct)
{
ethis = el_una(OPind, TYstruct, ethis);
ethis.ET = Type_toCtype(te.type);
}
elem_setLoc(ethis,te.loc);
return ethis;
}
/***************************************
*/
elem* visitInteger(IntegerExp ie)
{
elem *e = el_long(totym(ie.type), ie.getInteger());
elem_setLoc(e,ie.loc);
return e;
}
/***************************************
*/
elem* visitReal(RealExp re)
{
//printf("RealExp.toElem(%p) %s\n", re, re.toChars());
elem *e = el_long(TYint, 0);
tym_t ty = totym(re.type.toBasetype());
switch (tybasic(ty))
{
case TYfloat:
case TYifloat:
e.EV.Vfloat = cast(float) re.value;
break;
case TYdouble:
case TYidouble:
e.EV.Vdouble = cast(double) re.value;
break;
case TYldouble:
case TYildouble:
e.EV.Vldouble = re.value;
break;
default:
printf("ty = %d, tym = %x, re=%s, re.type=%s, re.type.toBasetype=%s\n",
re.type.ty, ty, re.toChars(), re.type.toChars(), re.type.toBasetype().toChars());
assert(0);
}
e.Ety = ty;
return e;
}
/***************************************
*/
elem* visitComplex(ComplexExp ce)
{
//printf("ComplexExp.toElem(%p) %s\n", ce, ce.toChars());
elem *e = el_long(TYint, 0);
real_t re = ce.value.re;
real_t im = ce.value.im;
tym_t ty = totym(ce.type);
switch (tybasic(ty))
{
case TYcfloat:
union UF { float f; uint i; }
e.EV.Vcfloat.re = cast(float) re;
if (CTFloat.isSNaN(re))
{
UF u;
u.f = e.EV.Vcfloat.re;
u.i &= 0xFFBFFFFFL;
e.EV.Vcfloat.re = u.f;
}
e.EV.Vcfloat.im = cast(float) im;
if (CTFloat.isSNaN(im))
{
UF u;
u.f = e.EV.Vcfloat.im;
u.i &= 0xFFBFFFFFL;
e.EV.Vcfloat.im = u.f;