elem *toEfilename(Module *m)
{
//printf("toEfilename(%s)\n", m->toChars());
const char *id = m->srcfile->toChars();
size_t len = strlen(id);
if (!m->sfilename)
{
// Put out as a static array
m->sfilename = toStringSymbol(id, len, 1);
}
// Turn static array into dynamic array
return el_pair(TYdarray, el_long(TYsize_t, len), el_ptr(m->sfilename));
}
void genObjFile(Module *m, bool multiobj)
{
//EEcontext *ee = env->getEEcontext();
//printf("Module::genobjfile(multiobj = %d) %s\n", multiobj, m->toChars());
if (m->ident == Id::entrypoint)
{
bool v = global.params.verbose;
global.params.verbose = false;
for (size_t i = 0; i < m->members->dim; i++)
{
Dsymbol *member = (*m->members)[i];
//printf("toObjFile %s %s\n", member->kind(), member->toChars());
toObjFile(member, global.params.multiobj);
}
global.params.verbose = v;
return;
}
lastmname = m->srcfile->toChars();
objmod->initfile(lastmname, NULL, m->toPrettyChars());
eictor = NULL;
ictorlocalgot = NULL;
sctors.setDim(0);
ectorgates.setDim(0);
sdtors.setDim(0);
ssharedctors.setDim(0);
esharedctorgates.setDim(0);
sshareddtors.setDim(0);
stests.setDim(0);
if (m->doppelganger)
{
/* Generate a reference to the moduleinfo, so the module constructors
* and destructors get linked in.
*/
Module *mod = m->aimports[0];
assert(mod);
if (mod->sictor || mod->sctor || mod->sdtor || mod->ssharedctor || mod->sshareddtor)
{
Symbol *s = toSymbol(mod);
//objextern(s);
//if (!s->Sxtrnnum) objextdef(s->Sident);
if (!s->Sxtrnnum)
{
//printf("%s\n", s->Sident);
#if 0 /* This should work, but causes optlink to fail in common/newlib.asm */
objextdef(s->Sident);
#else
Symbol *sref = symbol_generate(SCstatic, type_fake(TYnptr));
sref->Sfl = FLdata;
dtxoff(&sref->Sdt, s, 0, TYnptr);
outdata(sref);
#endif
}
}
}
if (global.params.cov)
{
/* Create coverage identifier:
* private uint[numlines] __coverage;
*/
m->cov = symbol_calloc("__coverage");
m->cov->Stype = type_fake(TYint);
m->cov->Stype->Tmangle = mTYman_c;
m->cov->Stype->Tcount++;
m->cov->Sclass = SCstatic;
m->cov->Sfl = FLdata;
dtnzeros(&m->cov->Sdt, 4 * m->numlines);
outdata(m->cov);
slist_add(m->cov);
m->covb = (unsigned *)calloc((m->numlines + 32) / 32, sizeof(*m->covb));
}
for (size_t i = 0; i < m->members->dim; i++)
{
Dsymbol *member = (*m->members)[i];
//printf("toObjFile %s %s\n", member->kind(), member->toChars());
toObjFile(member, multiobj);
}
if (global.params.cov)
{
/* Generate
* bit[numlines] __bcoverage;
*/
Symbol *bcov = symbol_calloc("__bcoverage");
bcov->Stype = type_fake(TYuint);
bcov->Stype->Tcount++;
bcov->Sclass = SCstatic;
bcov->Sfl = FLdata;
dtnbytes(&bcov->Sdt, (m->numlines + 32) / 32 * sizeof(*m->covb), (char *)m->covb);
outdata(bcov);
free(m->covb);
m->covb = NULL;
/* Generate:
* _d_cover_register(uint[] __coverage, BitArray __bcoverage, string filename);
* and prepend it to the static constructor.
*/
/* t will be the type of the functions generated:
* extern (C) void func();
*/
type *t = type_function(TYnfunc, NULL, 0, false, tsvoid);
t->Tmangle = mTYman_c;
m->sictor = toSymbolX(m, "__modictor", SCglobal, t, "FZv");
cstate.CSpsymtab = &m->sictor->Sfunc->Flocsym;
localgot = ictorlocalgot;
elem *ecov = el_pair(TYdarray, el_long(TYsize_t, m->numlines), el_ptr(m->cov));
elem *ebcov = el_pair(TYdarray, el_long(TYsize_t, m->numlines), el_ptr(bcov));
if (config.exe == EX_WIN64)
{
ecov = addressElem(ecov, Type::tvoid->arrayOf(), false);
ebcov = addressElem(ebcov, Type::tvoid->arrayOf(), false);
}
elem *efilename = toEfilename(m);
if (config.exe == EX_WIN64)
efilename = addressElem(efilename, Type::tstring, true);
elem *e = el_params(
el_long(TYuchar, global.params.covPercent),
ecov,
ebcov,
efilename,
NULL);
e = el_bin(OPcall, TYvoid, el_var(rtlsym[RTLSYM_DCOVER2]), e);
eictor = el_combine(e, eictor);
ictorlocalgot = localgot;
}
// If coverage / static constructor / destructor / unittest calls
if (eictor || sctors.dim || ectorgates.dim || sdtors.dim ||
ssharedctors.dim || esharedctorgates.dim || sshareddtors.dim || stests.dim)
{
if (eictor)
{
localgot = ictorlocalgot;
block *b = block_calloc();
b->BC = BCret;
b->Belem = eictor;
m->sictor->Sfunc->Fstartline.Sfilename = m->arg;
m->sictor->Sfunc->Fstartblock = b;
writefunc(m->sictor);
}
m->sctor = callFuncsAndGates(m, &sctors, &ectorgates, "__modctor");
m->sdtor = callFuncsAndGates(m, &sdtors, NULL, "__moddtor");
m->ssharedctor = callFuncsAndGates(m, &ssharedctors, (StaticDtorDeclarations *)&esharedctorgates, "__modsharedctor");
m->sshareddtor = callFuncsAndGates(m, &sshareddtors, NULL, "__modshareddtor");
m->stest = callFuncsAndGates(m, &stests, NULL, "__modtest");
if (m->doppelganger)
genModuleInfo(m);
}
if (m->doppelganger)
{
objmod->termfile();
return;
}
if (global.params.multiobj)
{
/* This is necessary because the main .obj for this module is written
* first, but determining whether marray or massert or munittest are needed is done
* possibly later in the doppelganger modules.
* Another way to fix it is do the main one last.
*/
toModuleAssert(m);
toModuleUnittest(m);
toModuleArray(m);
}
/* Always generate module info, because of templates and -cov.
* But module info needs the runtime library, so disable it for betterC.
*/
if (!global.params.betterC /*|| needModuleInfo()*/)
genModuleInfo(m);
genhelpers(m, false);
objmod->termfile();
}
void Module::genobjfile(int multiobj)
{
//EEcontext *ee = env->getEEcontext();
//printf("Module::genobjfile(multiobj = %d) %s\n", multiobj, toChars());
lastmname = srcfile->toChars();
objmod->initfile(lastmname, NULL, toPrettyChars());
eictor = NULL;
ictorlocalgot = NULL;
sctors.setDim(0);
ectorgates.setDim(0);
sdtors.setDim(0);
ssharedctors.setDim(0);
esharedctorgates.setDim(0);
sshareddtors.setDim(0);
stests.setDim(0);
dtorcount = 0;
shareddtorcount = 0;
if (doppelganger)
{
/* Generate a reference to the moduleinfo, so the module constructors
* and destructors get linked in.
*/
Module *m = aimports[0];
assert(m);
if (m->sictor || m->sctor || m->sdtor || m->ssharedctor || m->sshareddtor)
{
Symbol *s = m->toSymbol();
//objextern(s);
//if (!s->Sxtrnnum) objextdef(s->Sident);
if (!s->Sxtrnnum)
{
//printf("%s\n", s->Sident);
#if 0 /* This should work, but causes optlink to fail in common/newlib.asm */
objextdef(s->Sident);
#else
Symbol *sref = symbol_generate(SCstatic, type_fake(TYnptr));
sref->Sfl = FLdata;
dtxoff(&sref->Sdt, s, 0, TYnptr);
outdata(sref);
#endif
}
}
}
if (global.params.cov)
{
/* Create coverage identifier:
* private uint[numlines] __coverage;
*/
cov = symbol_calloc("__coverage");
cov->Stype = type_fake(TYint);
cov->Stype->Tmangle = mTYman_c;
cov->Stype->Tcount++;
cov->Sclass = SCstatic;
cov->Sfl = FLdata;
dtnzeros(&cov->Sdt, 4 * numlines);
outdata(cov);
slist_add(cov);
covb = (unsigned *)calloc((numlines + 32) / 32, sizeof(*covb));
}
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *member = (*members)[i];
//printf("toObjFile %s %s\n", member->kind(), member->toChars());
member->toObjFile(multiobj);
}
if (global.params.cov)
{
/* Generate
* bit[numlines] __bcoverage;
*/
Symbol *bcov = symbol_calloc("__bcoverage");
bcov->Stype = type_fake(TYuint);
bcov->Stype->Tcount++;
bcov->Sclass = SCstatic;
bcov->Sfl = FLdata;
dtnbytes(&bcov->Sdt, (numlines + 32) / 32 * sizeof(*covb), (char *)covb);
outdata(bcov);
free(covb);
covb = NULL;
/* Generate:
* _d_cover_register(uint[] __coverage, BitArray __bcoverage, string filename);
* and prepend it to the static constructor.
*/
/* t will be the type of the functions generated:
* extern (C) void func();
*/
type *t = type_function(TYnfunc, NULL, 0, false, tsvoid);
t->Tmangle = mTYman_c;
sictor = toSymbolX("__modictor", SCglobal, t, "FZv");
cstate.CSpsymtab = &sictor->Sfunc->Flocsym;
localgot = ictorlocalgot;
elem *ecov = el_pair(TYdarray, el_long(TYsize_t, numlines), el_ptr(cov));
elem *ebcov = el_pair(TYdarray, el_long(TYsize_t, numlines), el_ptr(bcov));
if (config.exe == EX_WIN64)
{
ecov = addressElem(ecov, Type::tvoid->arrayOf(), false);
ebcov = addressElem(ebcov, Type::tvoid->arrayOf(), false);
}
elem *e = el_params(
el_long(TYuchar, global.params.covPercent),
ecov,
ebcov,
toEfilename(),
NULL);
e = el_bin(OPcall, TYvoid, el_var(rtlsym[RTLSYM_DCOVER2]), e);
eictor = el_combine(e, eictor);
ictorlocalgot = localgot;
}
// If coverage / static constructor / destructor / unittest calls
if (eictor || sctors.dim || ectorgates.dim || sdtors.dim ||
ssharedctors.dim || esharedctorgates.dim || sshareddtors.dim || stests.dim)
{
if (eictor)
{
localgot = ictorlocalgot;
block *b = block_calloc();
b->BC = BCret;
b->Belem = eictor;
sictor->Sfunc->Fstartline.Sfilename = arg;
sictor->Sfunc->Fstartblock = b;
writefunc(sictor);
}
sctor = callFuncsAndGates(this, &sctors, &ectorgates, "__modctor");
sdtor = callFuncsAndGates(this, &sdtors, NULL, "__moddtor");
#if DMDV2
ssharedctor = callFuncsAndGates(this, &ssharedctors, (StaticDtorDeclarations *)&esharedctorgates, "__modsharedctor");
sshareddtor = callFuncsAndGates(this, &sshareddtors, NULL, "__modshareddtor");
#endif
stest = callFuncsAndGates(this, &stests, NULL, "__modtest");
if (doppelganger)
genmoduleinfo();
}
if (doppelganger)
{
objmod->termfile();
return;
}
if (global.params.multiobj)
{ /* This is necessary because the main .obj for this module is written
* first, but determining whether marray or massert or munittest are needed is done
* possibly later in the doppelganger modules.
* Another way to fix it is do the main one last.
*/
toModuleAssert();
toModuleUnittest();
toModuleArray();
}
/* Always generate module info, because of templates and -cov.
* But module info needs the runtime library, so disable it for betterC.
*/
if (!global.params.betterC /*|| needModuleInfo()*/)
genmoduleinfo();
// If module assert
for (int i = 0; i < 3; i++)
{
Symbol *ma;
unsigned rt;
unsigned bc;
switch (i)
{
case 0: ma = marray; rt = RTLSYM_DARRAY; bc = BCexit; break;
case 1: ma = massert; rt = RTLSYM_DASSERTM; bc = BCexit; break;
case 2: ma = munittest; rt = RTLSYM_DUNITTESTM; bc = BCret; break;
default: assert(0);
}
if (ma)
{
elem *elinnum;
localgot = NULL;
// Call dassert(filename, line)
// Get sole parameter, linnum
{
Symbol *sp = symbol_calloc("linnum");
sp->Stype = type_fake(TYint);
sp->Stype->Tcount++;
sp->Sclass = (config.exe == EX_WIN64) ? SCshadowreg : SCfastpar;
FuncParamRegs fpr(TYjfunc);
fpr.alloc(sp->Stype, sp->Stype->Tty, &sp->Spreg, &sp->Spreg2);
sp->Sflags &= ~SFLspill;
sp->Sfl = (sp->Sclass == SCshadowreg) ? FLpara : FLfast;
cstate.CSpsymtab = &ma->Sfunc->Flocsym;
symbol_add(sp);
elinnum = el_var(sp);
}
elem *efilename = el_ptr(toSymbol());
elem *e = el_var(rtlsym[rt]);
e = el_bin(OPcall, TYvoid, e, el_param(elinnum, efilename));
block *b = block_calloc();
b->BC = bc;
b->Belem = e;
ma->Sfunc->Fstartline.Sfilename = arg;
ma->Sfunc->Fstartblock = b;
ma->Sclass = SCglobal;
ma->Sfl = 0;
ma->Sflags |= rtlsym[rt]->Sflags & SFLexit;
writefunc(ma);
}
}
objmod->termfile();
}
void Module::genobjfile(int multiobj)
{
//EEcontext *ee = env->getEEcontext();
//printf("Module::genobjfile(multiobj = %d) %s\n", multiobj, toChars());
lastmname = srcfile->toChars();
obj_initfile(lastmname, NULL, toPrettyChars());
eictor = NULL;
ictorlocalgot = NULL;
sctors.setDim(0);
ectorgates.setDim(0);
sdtors.setDim(0);
ssharedctors.setDim(0);
esharedctorgates.setDim(0);
sshareddtors.setDim(0);
stests.setDim(0);
dtorcount = 0;
shareddtorcount = 0;
if (doppelganger)
{
/* Generate a reference to the moduleinfo, so the module constructors
* and destructors get linked in.
*/
Module *m = aimports[0];
assert(m);
if (m->sictor || m->sctor || m->sdtor || m->ssharedctor || m->sshareddtor)
{
Symbol *s = m->toSymbol();
//objextern(s);
//if (!s->Sxtrnnum) objextdef(s->Sident);
if (!s->Sxtrnnum)
{
//printf("%s\n", s->Sident);
#if 0 /* This should work, but causes optlink to fail in common/newlib.asm */
objextdef(s->Sident);
#else
#if ELFOBJ || MACHOBJ
int nbytes = reftoident(DATA, Offset(DATA), s, 0, I64 ? (CFoff | CFoffset64) : CFoff);
#else
int nbytes = reftoident(DATA, Doffset, s, 0, CFoff);
Doffset += nbytes;
#endif
#endif
}
}
}
if (global.params.cov)
{
/* Create coverage identifier:
* private uint[numlines] __coverage;
*/
cov = symbol_calloc("__coverage");
cov->Stype = type_fake(TYint);
cov->Stype->Tmangle = mTYman_c;
cov->Stype->Tcount++;
cov->Sclass = SCstatic;
cov->Sfl = FLdata;
#if ELFOBJ || MACHOBJ
cov->Sseg = UDATA;
#endif
dtnzeros(&cov->Sdt, 4 * numlines);
outdata(cov);
slist_add(cov);
covb = (unsigned *)calloc((numlines + 32) / 32, sizeof(*covb));
}
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *member = (*members)[i];
member->toObjFile(multiobj);
}
if (global.params.cov)
{
/* Generate
* bit[numlines] __bcoverage;
*/
Symbol *bcov = symbol_calloc("__bcoverage");
bcov->Stype = type_fake(TYuint);
bcov->Stype->Tcount++;
bcov->Sclass = SCstatic;
bcov->Sfl = FLdata;
#if ELFOBJ || MACHOBJ
bcov->Sseg = DATA;
#endif
dtnbytes(&bcov->Sdt, (numlines + 32) / 32 * sizeof(*covb), (char *)covb);
outdata(bcov);
free(covb);
covb = NULL;
/* Generate:
* _d_cover_register(uint[] __coverage, BitArray __bcoverage, string filename);
* and prepend it to the static constructor.
*/
/* t will be the type of the functions generated:
* extern (C) void func();
*/
type *t = type_alloc(TYnfunc);
t->Tflags |= TFprototype | TFfixed;
t->Tmangle = mTYman_c;
t->Tnext = tsvoid;
tsvoid->Tcount++;
sictor = toSymbolX("__modictor", SCglobal, t, "FZv");
cstate.CSpsymtab = &sictor->Sfunc->Flocsym;
localgot = ictorlocalgot;
elem *e;
e = el_params(el_pair(TYdarray, el_long(TYsize_t, numlines), el_ptr(cov)),
el_pair(TYdarray, el_long(TYsize_t, numlines), el_ptr(bcov)),
toEfilename(),
NULL);
e = el_bin(OPcall, TYvoid, el_var(rtlsym[RTLSYM_DCOVER]), e);
eictor = el_combine(e, eictor);
ictorlocalgot = localgot;
}
// If coverage / static constructor / destructor / unittest calls
if (eictor || sctors.dim || ectorgates.dim || sdtors.dim ||
ssharedctors.dim || esharedctorgates.dim || sshareddtors.dim || stests.dim)
{
if (eictor)
{
localgot = ictorlocalgot;
block *b = block_calloc();
b->BC = BCret;
b->Belem = eictor;
sictor->Sfunc->Fstartline.Sfilename = arg;
sictor->Sfunc->Fstartblock = b;
writefunc(sictor);
}
sctor = callFuncsAndGates(this, &sctors, &ectorgates, "__modctor");
sdtor = callFuncsAndGates(this, &sdtors, NULL, "__moddtor");
#if DMDV2
ssharedctor = callFuncsAndGates(this, &ssharedctors, (StaticDtorDeclarations *)&esharedctorgates, "__modsharedctor");
sshareddtor = callFuncsAndGates(this, &sshareddtors, NULL, "__modshareddtor");
#endif
stest = callFuncsAndGates(this, &stests, NULL, "__modtest");
if (doppelganger)
genmoduleinfo();
}
if (doppelganger)
{
obj_termfile();
return;
}
if (global.params.multiobj)
{ /* This is necessary because the main .obj for this module is written
* first, but determining whether marray or massert or munittest are needed is done
* possibly later in the doppelganger modules.
* Another way to fix it is do the main one last.
*/
toModuleAssert();
toModuleUnittest();
toModuleArray();
}
#if 1
// Always generate module info, because of templates and -cov
if (1 || needModuleInfo())
genmoduleinfo();
#endif
// If module assert
for (int i = 0; i < 3; i++)
{
Symbol *ma;
unsigned rt;
unsigned bc;
switch (i)
{
case 0: ma = marray; rt = RTLSYM_DARRAY; bc = BCexit; break;
case 1: ma = massert; rt = RTLSYM_DASSERTM; bc = BCexit; break;
case 2: ma = munittest; rt = RTLSYM_DUNITTESTM; bc = BCret; break;
default: assert(0);
}
if (ma)
{
elem *elinnum;
localgot = NULL;
// Call dassert(filename, line)
// Get sole parameter, linnum
{
Symbol *sp = symbol_calloc("linnum");
sp->Stype = type_fake(TYint);
sp->Stype->Tcount++;
sp->Sclass = SCfastpar;
size_t num;
sp->Spreg = getintegerparamsreglist(TYjfunc, &num)[0];
sp->Sflags &= ~SFLspill;
sp->Sfl = FLpara; // FLauto?
cstate.CSpsymtab = &ma->Sfunc->Flocsym;
symbol_add(sp);
elinnum = el_var(sp);
}
elem *efilename = el_ptr(toSymbol());
elem *e = el_var(rtlsym[rt]);
e = el_bin(OPcall, TYvoid, e, el_param(elinnum, efilename));
block *b = block_calloc();
b->BC = bc;
b->Belem = e;
ma->Sfunc->Fstartline.Sfilename = arg;
ma->Sfunc->Fstartblock = b;
ma->Sclass = SCglobal;
ma->Sfl = 0;
ma->Sflags |= rtlsym[rt]->Sflags & SFLexit;
writefunc(ma);
}
}
obj_termfile();
}
void ForeachStatement::toIR(IRState *irs)
{
printf("ForeachStatement::toIR() %s\n", toChars());
assert(0); // done by "lowering" in the front end
#if 0
Type *tab;
elem *eaggr;
elem *e;
elem *elength;
tym_t keytym;
//printf("ForeachStatement::toIR()\n");
block *bpre;
block *bcond;
block *bbody;
block *bbodyx;
Blockx *blx = irs->blx;
IRState mystate(irs,this);
mystate.breakBlock = block_calloc(blx);
mystate.contBlock = block_calloc(blx);
tab = aggr->type->toBasetype();
assert(tab->ty == Tarray || tab->ty == Tsarray);
incUsage(irs, aggr->loc);
eaggr = aggr->toElem(irs);
/* Create sp: pointer to start of array data
*/
Symbol *sp = symbol_genauto(TYnptr);
if (tab->ty == Tarray)
{
// stmp is copy of eaggr (the array), so eaggr is evaluated only once
Symbol *stmp;
// Initialize stmp
stmp = symbol_genauto(eaggr);
e = el_bin(OPeq, eaggr->Ety, el_var(stmp), eaggr);
block_appendexp(blx->curblock, e);
// Initialize sp
e = el_una(OPmsw, TYnptr, el_var(stmp));
e = el_bin(OPeq, TYnptr, el_var(sp), e);
block_appendexp(blx->curblock, e);
// Get array.length
elength = el_var(stmp);
elength->Ety = TYsize_t;
}
else // Tsarray
{
// Initialize sp
e = el_una(OPaddr, TYnptr, eaggr);
e = el_bin(OPeq, TYnptr, el_var(sp), e);
block_appendexp(blx->curblock, e);
// Get array.length
elength = el_long(TYsize_t, ((TypeSArray *)tab)->dim->toInteger());
}
Symbol *spmax;
Symbol *skey;
if (key)
{
/* Create skey, the index to the array.
* Initialize skey to 0 (foreach) or .length (foreach_reverse).
*/
skey = key->toSymbol();
symbol_add(skey);
keytym = key->type->totym();
elem *einit = (op == TOKforeach_reverse) ? elength : el_long(keytym, 0);
e = el_bin(OPeq, keytym, el_var(skey), einit);
}
else
{
/* Create spmax, pointer past end of data.
* Initialize spmax = sp + array.length * size
*/
spmax = symbol_genauto(TYnptr);
e = el_bin(OPmul, TYsize_t, elength, el_long(TYsize_t, tab->nextOf()->size()));
e = el_bin(OPadd, TYnptr, el_var(sp), e);
e = el_bin(OPeq, TYnptr, el_var(spmax), e);
/* For foreach_reverse, swap sp and spmax
*/
if (op == TOKforeach_reverse)
{ Symbol *s = sp;
sp = spmax;
spmax = s;
}
}
block_appendexp(blx->curblock, e);
bpre = blx->curblock;
block_next(blx,BCgoto,NULL);
bcond = blx->curblock;
if (key)
{
if (op == TOKforeach_reverse)
{
// Construct (key != 0)
e = el_bin(OPne, TYint, el_var(skey), el_long(keytym, 0));
}
else
{
// Construct (key < elength)
e = el_bin(OPlt, TYint, el_var(skey), elength);
}
}
else
{
if (op == TOKforeach_reverse)
{
// Construct (sp > spmax)
e = el_bin(OPgt, TYint, el_var(sp), el_var(spmax));
}
else
{
// Construct (sp < spmax)
e = el_bin(OPlt, TYint, el_var(sp), el_var(spmax));
}
}
bcond->Belem = e;
block_next(blx, BCiftrue, NULL);
if (op == TOKforeach_reverse)
{
if (key)
{ // Construct (skey -= 1)
e = el_bin(OPminass, keytym, el_var(skey), el_long(keytym, 1));
}
else
{ // Construct (sp--)
e = el_bin(OPminass, TYnptr, el_var(sp), el_long(TYsize_t, tab->nextOf()->size()));
}
block_appendexp(blx->curblock, e);
}
Symbol *s;
FuncDeclaration *fd = NULL;
if (value->toParent2())
fd = value->toParent2()->isFuncDeclaration();
int nrvo = 0;
if (fd && fd->nrvo_can && fd->nrvo_var == value)
{
s = fd->shidden;
nrvo = 1;
}
else
{ s = value->toSymbol();
symbol_add(s);
}
// Construct (value = *sp) or (value = sp[skey * elemsize])
tym_t tym = value->type->totym();
if (key)
{ // sp + skey * elemsize
e = el_bin(OPmul, keytym, el_var(skey), el_long(keytym, tab->nextOf()->size()));
e = el_bin(OPadd, TYnptr, el_var(sp), e);
}
else
e = el_var(sp);
elem *evalue;
#if DMDV2
if (value->offset) // if value is a member of a closure
{
assert(irs->sclosure);
evalue = el_var(irs->sclosure);
evalue = el_bin(OPadd, TYnptr, evalue, el_long(TYint, value->offset));
evalue = el_una(OPind, value->type->totym(), evalue);
}
else
#endif
evalue = el_var(s);
if (value->isOut() || value->isRef())
{
assert(value->storage_class & (STCout | STCref));
e = el_bin(OPeq, TYnptr, evalue, e);
}
else
{
if (nrvo)
evalue = el_una(OPind, tym, evalue);
StructDeclaration *sd = needsPostblit(value->type);
if (tybasic(tym) == TYstruct)
{
e = el_bin(OPeq, tym, evalue, el_una(OPind, tym, e));
e->Eoper = OPstreq;
e->ET = value->type->toCtype();
#if DMDV2
// Call postblit on e
if (sd)
{ FuncDeclaration *fd = sd->postblit;
elem *ec = el_copytree(evalue);
ec = el_una(OPaddr, TYnptr, ec);
ec = callfunc(loc, irs, 1, Type::tvoid, ec, sd->type->pointerTo(), fd, fd->type, NULL, NULL);
e = el_combine(e, ec);
}
#endif
}
else if (tybasic(tym) == TYarray)
{
if (sd)
{
/* Generate:
* _d_arrayctor(ti, efrom, eto)
*/
Expression *ti = value->type->toBasetype()->nextOf()->toBasetype()->getTypeInfo(NULL);
elem *esize = el_long(TYsize_t, ((TypeSArray *)value->type->toBasetype())->dim->toInteger());
elem *eto = el_pair(TYdarray, esize, el_una(OPaddr, TYnptr, evalue));
elem *efrom = el_pair(TYdarray, el_copytree(esize), e);
elem *ep = el_params(eto, efrom, ti->toElem(irs), NULL);
int rtl = RTLSYM_ARRAYCTOR;
e = el_bin(OPcall, TYvoid, el_var(rtlsym[rtl]), ep);
}
else
{
e = el_bin(OPeq, tym, evalue, el_una(OPind, tym, e));
e->Eoper = OPstreq;
e->Ejty = e->Ety = TYstruct;
e->ET = value->type->toCtype();
}
}
else
e = el_bin(OPeq, tym, evalue, el_una(OPind, tym, e));
}
incUsage(irs, loc);
block_appendexp(blx->curblock, e);
bbody = blx->curblock;
if (body)
body->toIR(&mystate);
bbodyx = blx->curblock;
block_next(blx,BCgoto,mystate.contBlock);
if (op == TOKforeach)
{
if (key)
{ // Construct (skey += 1)
e = el_bin(OPaddass, keytym, el_var(skey), el_long(keytym, 1));
}
else
{ // Construct (sp++)
e = el_bin(OPaddass, TYnptr, el_var(sp), el_long(TYsize_t, tab->nextOf()->size()));
}
mystate.contBlock->Belem = e;
}
block_next(blx,BCgoto,mystate.breakBlock);
list_append(&bpre->Bsucc,bcond);
list_append(&bcond->Bsucc,bbody);
list_append(&bcond->Bsucc,mystate.breakBlock);
list_append(&bbodyx->Bsucc,mystate.contBlock);
list_append(&mystate.contBlock->Bsucc,bcond);
#endif
}