elem *setEthis(Loc loc, IRState *irs, elem *ey, AggregateDeclaration *ad)
{
elem *ethis;
FuncDeclaration *thisfd = irs->getFunc();
int offset = 0;
Dsymbol *cdp = ad->toParent2(); // class/func we're nested in
//printf("setEthis(ad = %s, cdp = %s, thisfd = %s)\n", ad->toChars(), cdp->toChars(), thisfd->toChars());
if (cdp == thisfd)
{ /* Class we're new'ing is a local class in this function:
* void thisfd() { class ad { } }
*/
if (irs->sclosure)
ethis = el_var(irs->sclosure);
else if (irs->sthis)
{
if (thisfd->hasNestedFrameRefs())
{
ethis = el_ptr(irs->sthis);
}
else
ethis = el_var(irs->sthis);
}
else
{
ethis = el_long(TYnptr, 0);
if (thisfd->hasNestedFrameRefs())
{
ethis->Eoper = OPframeptr;
}
}
}
else if (thisfd->vthis &&
(cdp == thisfd->toParent2() ||
(cdp->isClassDeclaration() &&
cdp->isClassDeclaration()->isBaseOf(thisfd->toParent2()->isClassDeclaration(), &offset)
)
)
)
{ /* Class we're new'ing is at the same level as thisfd
*/
assert(offset == 0); // BUG: should handle this case
ethis = el_var(irs->sthis);
}
else
{
ethis = getEthis(loc, irs, ad->toParent2());
ethis = el_una(OPaddr, TYnptr, ethis);
}
ey = el_bin(OPadd, TYnptr, ey, el_long(TYsize_t, ad->vthis->offset));
ey = el_una(OPind, TYnptr, ey);
ey = el_bin(OPeq, TYnptr, ey, ethis);
return ey;
}
ClassDeclaration *Dsymbol::isClassMember() // are we a member of a class?
{
Dsymbol *parent = toParent();
if (parent && parent->isClassDeclaration())
return (ClassDeclaration *)parent;
return NULL;
}
llvm::FunctionType* DtoBaseFunctionType(FuncDeclaration* fdecl)
{
Dsymbol* parent = fdecl->toParent();
ClassDeclaration* cd = parent->isClassDeclaration();
assert(cd);
FuncDeclaration* f = fdecl;
while (cd)
{
ClassDeclaration* base = cd->baseClass;
if (!base)
break;
FuncDeclaration* f2 = base->findFunc(fdecl->ident, (TypeFunction*)fdecl->type);
if (f2) {
f = f2;
cd = base;
}
else
break;
}
DtoResolveDsymbol(f);
return llvm::cast<llvm::FunctionType>(DtoType(f->type));
}
/*************************
* Initialize the hidden aggregate member, vthis, with
* the context pointer.
* Returns:
* *(ey + ad.vthis.offset) = this;
*/
elem *setEthis(Loc loc, IRState *irs, elem *ey, AggregateDeclaration *ad)
{
elem *ethis;
FuncDeclaration *thisfd = irs->getFunc();
int offset = 0;
Dsymbol *adp = ad->toParent2(); // class/func we're nested in
//printf("[%s] setEthis(ad = %s, adp = %s, thisfd = %s)\n", loc.toChars(), ad->toChars(), adp->toChars(), thisfd->toChars());
if (adp == thisfd)
{
ethis = getEthis(loc, irs, ad);
}
else if (thisfd->vthis &&
(adp == thisfd->toParent2() ||
(adp->isClassDeclaration() &&
adp->isClassDeclaration()->isBaseOf(thisfd->toParent2()->isClassDeclaration(), &offset)
)
)
)
{
/* Class we're new'ing is at the same level as thisfd
*/
assert(offset == 0); // BUG: should handle this case
ethis = el_var(irs->sthis);
}
else
{
ethis = getEthis(loc, irs, adp);
FuncDeclaration *fdp = adp->isFuncDeclaration();
if (fdp && fdp->hasNestedFrameRefs())
ethis = el_una(OPaddr, TYnptr, ethis);
}
ey = el_bin(OPadd, TYnptr, ey, el_long(TYsize_t, ad->vthis->offset));
ey = el_una(OPind, TYnptr, ey);
ey = el_bin(OPeq, TYnptr, ey, ethis);
return ey;
}
Symbol *FuncDeclaration::toSymbol()
{
if (!csym)
{ Symbol *s;
TYPE *t;
const char *id;
#if 0
id = ident->toChars();
#else
id = mangle();
#endif
//printf("FuncDeclaration::toSymbol(%s %s)\n", kind(), toChars());
//printf("\tid = '%s'\n", id);
//printf("\ttype = %s\n", type->toChars());
s = symbol_calloc(id);
slist_add(s);
{
s->prettyIdent = toPrettyChars();
s->Sclass = SCglobal;
symbol_func(s);
func_t *f = s->Sfunc;
if (isVirtual() && vtblIndex != -1)
f->Fflags |= Fvirtual;
else if (isMember2() && isStatic())
f->Fflags |= Fstatic;
f->Fstartline.Slinnum = loc.linnum;
f->Fstartline.Sfilename = (char *)loc.filename;
if (endloc.linnum)
{ f->Fendline.Slinnum = endloc.linnum;
f->Fendline.Sfilename = (char *)endloc.filename;
}
else
{ f->Fendline.Slinnum = loc.linnum;
f->Fendline.Sfilename = (char *)loc.filename;
}
t = type->toCtype();
}
mangle_t msave = t->Tmangle;
if (isMain())
{
t->Tty = TYnfunc;
t->Tmangle = mTYman_c;
}
else
{
switch (linkage)
{
case LINKwindows:
t->Tmangle = mTYman_std;
break;
case LINKpascal:
t->Tty = TYnpfunc;
t->Tmangle = mTYman_pas;
break;
case LINKc:
t->Tmangle = mTYman_c;
break;
case LINKd:
t->Tmangle = mTYman_d;
break;
case LINKcpp:
{ t->Tmangle = mTYman_cpp;
if (isThis() && !global.params.is64bit && global.params.isWindows)
t->Tty = TYmfunc;
s->Sflags |= SFLpublic;
Dsymbol *parent = toParent();
ClassDeclaration *cd = parent->isClassDeclaration();
if (cd)
{
::type *tc = cd->type->toCtype();
s->Sscope = tc->Tnext->Ttag;
}
StructDeclaration *sd = parent->isStructDeclaration();
if (sd)
{
::type *ts = sd->type->toCtype();
s->Sscope = ts->Ttag;
}
break;
}
default:
printf("linkage = %d\n", linkage);
assert(0);
}
}
if (msave)
assert(msave == t->Tmangle);
//printf("Tty = %x, mangle = x%x\n", t->Tty, t->Tmangle);
t->Tcount++;
s->Stype = t;
//s->Sfielddef = this;
csym = s;
}
return csym;
}
Symbol *VarDeclaration::toSymbol()
{
//printf("VarDeclaration::toSymbol(%s)\n", toChars());
//if (needThis()) *(char*)0=0;
assert(!needThis());
if (!csym)
{
TYPE *t;
const char *id;
if (isDataseg())
id = mangle();
else
id = ident->toChars();
Symbol *s = symbol_calloc(id);
s->Salignment = alignment;
if (storage_class & (STCout | STCref))
{
// should be TYref, but problems in back end
t = type_pointer(type->toCtype());
}
else if (storage_class & STClazy)
{
if (config.exe == EX_WIN64 && isParameter())
t = type_fake(TYnptr);
else
t = type_fake(TYdelegate); // Tdelegate as C type
t->Tcount++;
}
else if (isParameter())
{
if (config.exe == EX_WIN64 && type->size(Loc()) > REGSIZE)
{
// should be TYref, but problems in back end
t = type_pointer(type->toCtype());
}
else
{
t = type->toCParamtype();
t->Tcount++;
}
}
else
{
t = type->toCtype();
t->Tcount++;
}
if (isDataseg())
{
if (isThreadlocal())
{ /* Thread local storage
*/
TYPE *ts = t;
ts->Tcount++; // make sure a different t is allocated
type_setty(&t, t->Tty | mTYthread);
ts->Tcount--;
if (global.params.vtls)
{
char *p = loc.toChars();
fprintf(stderr, "%s: %s is thread local\n", p ? p : "", toChars());
if (p)
mem.free(p);
}
}
s->Sclass = SCextern;
s->Sfl = FLextern;
slist_add(s);
/* if it's global or static, then it needs to have a qualified but unmangled name.
* This gives some explanation of the separation in treating name mangling.
* It applies to PDB format, but should apply to CV as PDB derives from CV.
* http://msdn.microsoft.com/en-us/library/ff553493(VS.85).aspx
*/
s->prettyIdent = toPrettyChars();
}
else
{
s->Sclass = SCauto;
s->Sfl = FLauto;
if (nestedrefs.dim)
{
/* Symbol is accessed by a nested function. Make sure
* it is not put in a register, and that the optimizer
* assumes it is modified across function calls and pointer
* dereferences.
*/
//printf("\tnested ref, not register\n");
type_setcv(&t, t->Tty | mTYvolatile);
}
}
if (ident == Id::va_argsave)
/* __va_argsave is set outside of the realm of the optimizer,
* so we tell the optimizer to leave it alone
*/
type_setcv(&t, t->Tty | mTYvolatile);
mangle_t m = 0;
switch (linkage)
{
case LINKwindows:
m = mTYman_std;
break;
case LINKpascal:
m = mTYman_pas;
break;
case LINKc:
m = mTYman_c;
break;
case LINKd:
m = mTYman_d;
break;
case LINKcpp:
{
m = mTYman_cpp;
s->Sflags = SFLpublic;
Dsymbol *parent = toParent();
ClassDeclaration *cd = parent->isClassDeclaration();
if (cd)
{
::type *tc = cd->type->toCtype();
s->Sscope = tc->Tnext->Ttag;
}
StructDeclaration *sd = parent->isStructDeclaration();
if (sd)
{
::type *ts = sd->type->toCtype();
s->Sscope = ts->Ttag;
}
break;
}
default:
printf("linkage = %d\n", linkage);
assert(0);
}
type_setmangle(&t, m);
s->Stype = t;
csym = s;
}
return csym;
}
void ClassDeclaration::semantic(Scope *sc)
{
//printf("ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
//printf("\tparent = %p, '%s'\n", sc->parent, sc->parent ? sc->parent->toChars() : "");
//printf("sc->stc = %x\n", sc->stc);
//{ static int n; if (++n == 20) *(char*)0=0; }
if (!ident) // if anonymous class
{ const char *id = "__anonclass";
ident = Identifier::generateId(id);
}
if (!sc)
sc = scope;
if (!parent && sc->parent && !sc->parent->isModule())
parent = sc->parent;
type = type->semantic(loc, sc);
handle = type;
if (!members) // if forward reference
{ //printf("\tclass '%s' is forward referenced\n", toChars());
return;
}
if (symtab)
{ if (sizeok == SIZEOKdone || !scope)
{ //printf("\tsemantic for '%s' is already completed\n", toChars());
return; // semantic() already completed
}
}
else
symtab = new DsymbolTable();
Scope *scx = NULL;
if (scope)
{ sc = scope;
scx = scope; // save so we don't make redundant copies
scope = NULL;
}
unsigned dprogress_save = Module::dprogress;
int errors = global.gaggedErrors;
if (sc->stc & STCdeprecated)
{
isdeprecated = true;
}
userAttributes = sc->userAttributes;
if (sc->linkage == LINKcpp)
error("cannot create C++ classes");
// Expand any tuples in baseclasses[]
for (size_t i = 0; i < baseclasses->dim; )
{ BaseClass *b = (*baseclasses)[i];
b->type = b->type->semantic(loc, sc);
Type *tb = b->type->toBasetype();
if (tb->ty == Ttuple)
{ TypeTuple *tup = (TypeTuple *)tb;
enum PROT protection = b->protection;
baseclasses->remove(i);
size_t dim = Parameter::dim(tup->arguments);
for (size_t j = 0; j < dim; j++)
{ Parameter *arg = Parameter::getNth(tup->arguments, j);
b = new BaseClass(arg->type, protection);
baseclasses->insert(i + j, b);
}
}
else
i++;
}
// See if there's a base class as first in baseclasses[]
if (baseclasses->dim)
{ TypeClass *tc;
BaseClass *b;
Type *tb;
b = (*baseclasses)[0];
//b->type = b->type->semantic(loc, sc);
tb = b->type->toBasetype();
if (tb->ty != Tclass)
{ if (b->type != Type::terror)
error("base type must be class or interface, not %s", b->type->toChars());
baseclasses->remove(0);
}
else
{
tc = (TypeClass *)(tb);
if (tc->sym->isDeprecated())
{
if (!isDeprecated())
{
// Deriving from deprecated class makes this one deprecated too
isdeprecated = true;
tc->checkDeprecated(loc, sc);
}
}
if (tc->sym->isInterfaceDeclaration())
;
else
{
for (ClassDeclaration *cdb = tc->sym; cdb; cdb = cdb->baseClass)
{
if (cdb == this)
{
error("circular inheritance");
baseclasses->remove(0);
goto L7;
}
}
if (!tc->sym->symtab || tc->sym->sizeok == SIZEOKnone)
{ // Try to resolve forward reference
if (/*sc->mustsemantic &&*/ tc->sym->scope)
tc->sym->semantic(NULL);
}
if (!tc->sym->symtab || tc->sym->scope || tc->sym->sizeok == SIZEOKnone)
{
//printf("%s: forward reference of base class %s\n", toChars(), tc->sym->toChars());
//error("forward reference of base class %s", baseClass->toChars());
// Forward reference of base class, try again later
//printf("\ttry later, forward reference of base class %s\n", tc->sym->toChars());
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
if (tc->sym->scope)
tc->sym->scope->module->addDeferredSemantic(tc->sym);
scope->module->addDeferredSemantic(this);
return;
}
else
{ baseClass = tc->sym;
b->base = baseClass;
}
L7: ;
}
}
}
// Treat the remaining entries in baseclasses as interfaces
// Check for errors, handle forward references
for (size_t i = (baseClass ? 1 : 0); i < baseclasses->dim; )
{ TypeClass *tc;
BaseClass *b;
Type *tb;
b = (*baseclasses)[i];
b->type = b->type->semantic(loc, sc);
tb = b->type->toBasetype();
if (tb->ty == Tclass)
tc = (TypeClass *)tb;
else
tc = NULL;
if (!tc || !tc->sym->isInterfaceDeclaration())
{ if (b->type != Type::terror)
error("base type must be interface, not %s", b->type->toChars());
baseclasses->remove(i);
continue;
}
else
{
if (tc->sym->isDeprecated())
{
if (!isDeprecated())
{
// Deriving from deprecated class makes this one deprecated too
isdeprecated = true;
tc->checkDeprecated(loc, sc);
}
}
// Check for duplicate interfaces
for (size_t j = (baseClass ? 1 : 0); j < i; j++)
{
BaseClass *b2 = (*baseclasses)[j];
if (b2->base == tc->sym)
error("inherits from duplicate interface %s", b2->base->toChars());
}
if (!tc->sym->symtab)
{ // Try to resolve forward reference
if (/*sc->mustsemantic &&*/ tc->sym->scope)
tc->sym->semantic(NULL);
}
b->base = tc->sym;
if (!b->base->symtab || b->base->scope)
{
//error("forward reference of base class %s", baseClass->toChars());
// Forward reference of base, try again later
//printf("\ttry later, forward reference of base %s\n", baseClass->toChars());
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
if (tc->sym->scope)
tc->sym->scope->module->addDeferredSemantic(tc->sym);
scope->module->addDeferredSemantic(this);
return;
}
}
i++;
}
// If no base class, and this is not an Object, use Object as base class
if (!baseClass && ident != Id::Object)
{
if (!object)
{
error("missing or corrupt object.d");
fatal();
}
Type *t = object->type;
t = t->semantic(loc, sc)->toBasetype();
assert(t->ty == Tclass);
TypeClass *tc = (TypeClass *)t;
BaseClass *b = new BaseClass(tc, PROTpublic);
baseclasses->shift(b);
baseClass = tc->sym;
assert(!baseClass->isInterfaceDeclaration());
b->base = baseClass;
}
interfaces_dim = baseclasses->dim;
interfaces = baseclasses->tdata();
if (baseClass)
{
if (baseClass->storage_class & STCfinal)
error("cannot inherit from final class %s", baseClass->toChars());
interfaces_dim--;
interfaces++;
// Copy vtbl[] from base class
vtbl.setDim(baseClass->vtbl.dim);
memcpy(vtbl.tdata(), baseClass->vtbl.tdata(), sizeof(void *) * vtbl.dim);
// Inherit properties from base class
com = baseClass->isCOMclass();
isscope = baseClass->isscope;
vthis = baseClass->vthis;
storage_class |= baseClass->storage_class & STC_TYPECTOR;
}
else
{
// No base class, so this is the root of the class hierarchy
vtbl.setDim(0);
vtbl.push(this); // leave room for classinfo as first member
}
protection = sc->protection;
storage_class |= sc->stc;
if (sizeok == SIZEOKnone)
{
interfaceSemantic(sc);
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (*members)[i];
s->addMember(sc, this, 1);
}
/* If this is a nested class, add the hidden 'this'
* member which is a pointer to the enclosing scope.
*/
if (vthis) // if inheriting from nested class
{ // Use the base class's 'this' member
isnested = true;
if (storage_class & STCstatic)
error("static class cannot inherit from nested class %s", baseClass->toChars());
if (toParent2() != baseClass->toParent2() &&
(!toParent2() ||
!baseClass->toParent2()->getType() ||
!baseClass->toParent2()->getType()->isBaseOf(toParent2()->getType(), NULL)))
{
if (toParent2())
{
error("is nested within %s, but super class %s is nested within %s",
toParent2()->toChars(),
baseClass->toChars(),
baseClass->toParent2()->toChars());
}
else
{
error("is not nested, but super class %s is nested within %s",
baseClass->toChars(),
baseClass->toParent2()->toChars());
}
isnested = false;
}
}
else if (!(storage_class & STCstatic))
{ Dsymbol *s = toParent2();
if (s)
{
AggregateDeclaration *ad = s->isClassDeclaration();
FuncDeclaration *fd = s->isFuncDeclaration();
if (ad || fd)
{ isnested = true;
Type *t;
if (ad)
t = ad->handle;
else if (fd)
{ AggregateDeclaration *ad2 = fd->isMember2();
if (ad2)
t = ad2->handle;
else
{
t = Type::tvoidptr;
}
}
else
assert(0);
if (t->ty == Tstruct) // ref to struct
t = Type::tvoidptr;
assert(!vthis);
vthis = new ThisDeclaration(loc, t);
members->push(vthis);
}
}
}
}
if (storage_class & STCauto)
error("storage class 'auto' is invalid when declaring a class, did you mean to use 'scope'?");
if (storage_class & STCscope)
isscope = 1;
if (storage_class & STCabstract)
isabstract = 1;
sc = sc->push(this);
//sc->stc &= ~(STCfinal | STCauto | STCscope | STCstatic | STCabstract | STCdeprecated | STC_TYPECTOR | STCtls | STCgshared);
//sc->stc |= storage_class & STC_TYPECTOR;
sc->stc &= STCsafe | STCtrusted | STCsystem;
sc->parent = this;
sc->inunion = 0;
if (isCOMclass())
{
#if IN_LLVM
if (global.params.targetTriple.isOSWindows())
#else
if (global.params.isWindows)
#endif
sc->linkage = LINKwindows;
else
/* This enables us to use COM objects under Linux and
* work with things like XPCOM
*/
sc->linkage = LINKc;
}
sc->protection = PROTpublic;
sc->explicitProtection = 0;
sc->structalign = STRUCTALIGN_DEFAULT;
if (baseClass)
{ sc->offset = baseClass->structsize;
alignsize = baseClass->alignsize;
// if (isnested)
// sc->offset += PTRSIZE; // room for uplevel context pointer
}
else
{ sc->offset = PTRSIZE * 2; // allow room for __vptr and __monitor
alignsize = PTRSIZE;
}
sc->userAttributes = NULL;
structsize = sc->offset;
Scope scsave = *sc;
size_t members_dim = members->dim;
sizeok = SIZEOKnone;
/* Set scope so if there are forward references, we still might be able to
* resolve individual members like enums.
*/
for (size_t i = 0; i < members_dim; i++)
{ Dsymbol *s = (*members)[i];
/* There are problems doing this in the general case because
* Scope keeps track of things like 'offset'
*/
if (s->isEnumDeclaration() ||
(s->isAggregateDeclaration() && s->ident) ||
s->isTemplateMixin() ||
s->isAttribDeclaration() ||
s->isAliasDeclaration())
{
//printf("[%d] setScope %s %s, sc = %p\n", i, s->kind(), s->toChars(), sc);
s->setScope(sc);
}
}
for (size_t i = 0; i < members_dim; i++)
{ Dsymbol *s = (*members)[i];
s->semantic(sc);
}
// Set the offsets of the fields and determine the size of the class
unsigned offset = structsize;
bool isunion = isUnionDeclaration() != NULL;
for (size_t i = 0; i < members->dim; i++)
{ Dsymbol *s = (*members)[i];
s->setFieldOffset(this, &offset, false);
}
sc->offset = structsize;
if (global.gag && global.gaggedErrors != errors)
{ // The type is no good, yet the error messages were gagged.
type = Type::terror;
}
if (sizeok == SIZEOKfwd) // failed due to forward references
{ // semantic() failed due to forward references
// Unwind what we did, and defer it for later
for (size_t i = 0; i < fields.dim; i++)
{ Dsymbol *s = fields[i];
VarDeclaration *vd = s->isVarDeclaration();
if (vd)
vd->offset = 0;
}
fields.setDim(0);
structsize = 0;
alignsize = 0;
// structalign = 0;
sc = sc->pop();
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
scope->module->addDeferredSemantic(this);
Module::dprogress = dprogress_save;
//printf("\tsemantic('%s') failed due to forward references\n", toChars());
return;
}
//printf("\tsemantic('%s') successful\n", toChars());
//members->print();
/* Look for special member functions.
* They must be in this class, not in a base class.
*/
ctor = search(0, Id::ctor, 0);
#if DMDV1
if (ctor && (ctor->toParent() != this || !ctor->isCtorDeclaration()))
ctor = NULL;
#else
if (ctor && (ctor->toParent() != this || !(ctor->isCtorDeclaration() || ctor->isTemplateDeclaration())))
ctor = NULL; // search() looks through ancestor classes
#endif
// dtor = (DtorDeclaration *)search(Id::dtor, 0);
// if (dtor && dtor->toParent() != this)
// dtor = NULL;
// inv = (InvariantDeclaration *)search(Id::classInvariant, 0);
// if (inv && inv->toParent() != this)
// inv = NULL;
// Can be in base class
aggNew = (NewDeclaration *)search(0, Id::classNew, 0);
aggDelete = (DeleteDeclaration *)search(0, Id::classDelete, 0);
// If this class has no constructor, but base class does, create
// a constructor:
// this() { }
if (!ctor && baseClass && baseClass->ctor)
{
//printf("Creating default this(){} for class %s\n", toChars());
Type *tf = new TypeFunction(NULL, NULL, 0, LINKd, 0);
CtorDeclaration *ctor = new CtorDeclaration(loc, 0, 0, tf);
ctor->isImplicit = true;
ctor->fbody = new CompoundStatement(0, new Statements());
members->push(ctor);
ctor->addMember(sc, this, 1);
*sc = scsave; // why? What about sc->nofree?
ctor->semantic(sc);
this->ctor = ctor;
defaultCtor = ctor;
}
#if 0
if (baseClass)
{ if (!aggDelete)
aggDelete = baseClass->aggDelete;
if (!aggNew)
aggNew = baseClass->aggNew;
}
#endif
// Allocate instance of each new interface
sc->offset = structsize;
for (size_t i = 0; i < vtblInterfaces->dim; i++)
{
BaseClass *b = (*vtblInterfaces)[i];
unsigned thissize = PTRSIZE;
alignmember(STRUCTALIGN_DEFAULT, thissize, &sc->offset);
assert(b->offset == 0);
b->offset = sc->offset;
// Take care of single inheritance offsets
while (b->baseInterfaces_dim)
{
b = &b->baseInterfaces[0];
b->offset = sc->offset;
}
sc->offset += thissize;
if (alignsize < thissize)
alignsize = thissize;
}
structsize = sc->offset;
#if IN_LLVM
if (sc->structalign == STRUCTALIGN_DEFAULT)
structsize = (structsize + alignsize - 1) & ~(alignsize - 1);
else
structsize = (structsize + sc->structalign - 1) & ~(sc->structalign - 1);
#endif
sizeok = SIZEOKdone;
Module::dprogress++;
dtor = buildDtor(sc);
if (Dsymbol *assign = search_function(this, Id::assign))
{
if (FuncDeclaration *f = hasIdentityOpAssign(sc, assign))
{
if (!(f->storage_class & STCdisable))
error("identity assignment operator overload is illegal");
}
}
sc->pop();
#if 0 // Do not call until toObjfile() because of forward references
// Fill in base class vtbl[]s
for (i = 0; i < vtblInterfaces->dim; i++)
{
BaseClass *b = (*vtblInterfaces)[i];
//b->fillVtbl(this, &b->vtbl, 1);
}
#endif
//printf("-ClassDeclaration::semantic(%s), type = %p\n", toChars(), type);
if (deferred && !global.gag)
{
deferred->semantic2(sc);
deferred->semantic3(sc);
}
}
Expression *semanticTraits(TraitsExp *e, Scope *sc)
{
#if LOGSEMANTIC
printf("TraitsExp::semantic() %s\n", e->toChars());
#endif
if (e->ident != Id::compiles && e->ident != Id::isSame &&
e->ident != Id::identifier && e->ident != Id::getProtection)
{
if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 1))
return new ErrorExp();
}
size_t dim = e->args ? e->args->dim : 0;
if (e->ident == Id::isArithmetic)
{
return isTypeX(e, &isTypeArithmetic);
}
else if (e->ident == Id::isFloating)
{
return isTypeX(e, &isTypeFloating);
}
else if (e->ident == Id::isIntegral)
{
return isTypeX(e, &isTypeIntegral);
}
else if (e->ident == Id::isScalar)
{
return isTypeX(e, &isTypeScalar);
}
else if (e->ident == Id::isUnsigned)
{
return isTypeX(e, &isTypeUnsigned);
}
else if (e->ident == Id::isAssociativeArray)
{
return isTypeX(e, &isTypeAssociativeArray);
}
else if (e->ident == Id::isStaticArray)
{
return isTypeX(e, &isTypeStaticArray);
}
else if (e->ident == Id::isAbstractClass)
{
return isTypeX(e, &isTypeAbstractClass);
}
else if (e->ident == Id::isFinalClass)
{
return isTypeX(e, &isTypeFinalClass);
}
else if (e->ident == Id::isPOD)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Type *t = isType(o);
StructDeclaration *sd;
if (!t)
{
e->error("type expected as second argument of __traits %s instead of %s", e->ident->toChars(), o->toChars());
goto Lfalse;
}
Type *tb = t->baseElemOf();
if (tb->ty == Tstruct
&& ((sd = (StructDeclaration *)(((TypeStruct *)tb)->sym)) != NULL))
{
if (sd->isPOD())
goto Ltrue;
else
goto Lfalse;
}
goto Ltrue;
}
else if (e->ident == Id::isNested)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
AggregateDeclaration *a;
FuncDeclaration *f;
if (!s) { }
else if ((a = s->isAggregateDeclaration()) != NULL)
{
if (a->isNested())
goto Ltrue;
else
goto Lfalse;
}
else if ((f = s->isFuncDeclaration()) != NULL)
{
if (f->isNested())
goto Ltrue;
else
goto Lfalse;
}
e->error("aggregate or function expected instead of '%s'", o->toChars());
goto Lfalse;
}
else if (e->ident == Id::isAbstractFunction)
{
return isFuncX(e, &isFuncAbstractFunction);
}
else if (e->ident == Id::isVirtualFunction)
{
return isFuncX(e, &isFuncVirtualFunction);
}
else if (e->ident == Id::isVirtualMethod)
{
return isFuncX(e, &isFuncVirtualMethod);
}
else if (e->ident == Id::isFinalFunction)
{
return isFuncX(e, &isFuncFinalFunction);
}
else if (e->ident == Id::isOverrideFunction)
{
return isFuncX(e, &isFuncOverrideFunction);
}
else if (e->ident == Id::isStaticFunction)
{
return isFuncX(e, &isFuncStaticFunction);
}
else if (e->ident == Id::isRef)
{
return isDeclX(e, &isDeclRef);
}
else if (e->ident == Id::isOut)
{
return isDeclX(e, &isDeclOut);
}
else if (e->ident == Id::isLazy)
{
return isDeclX(e, &isDeclLazy);
}
else if (e->ident == Id::identifier)
{
// Get identifier for symbol as a string literal
/* Specify 0 for bit 0 of the flags argument to semanticTiargs() so that
* a symbol should not be folded to a constant.
* Bit 1 means don't convert Parameter to Type if Parameter has an identifier
*/
if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 2))
return new ErrorExp();
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Parameter *po = isParameter(o);
Identifier *id;
if (po)
{
id = po->ident;
assert(id);
}
else
{
Dsymbol *s = getDsymbol(o);
if (!s || !s->ident)
{
e->error("argument %s has no identifier", o->toChars());
goto Lfalse;
}
id = s->ident;
}
StringExp *se = new StringExp(e->loc, id->toChars());
return se->semantic(sc);
}
else if (e->ident == Id::getProtection)
{
if (dim != 1)
goto Ldimerror;
Scope *sc2 = sc->push();
sc2->flags = sc->flags | SCOPEnoaccesscheck;
bool ok = TemplateInstance::semanticTiargs(e->loc, sc2, e->args, 1);
sc2->pop();
if (!ok)
return new ErrorExp();
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (!s)
{
if (!isError(o))
e->error("argument %s has no protection", o->toChars());
goto Lfalse;
}
if (s->scope)
s->semantic(s->scope);
PROT protection = s->prot();
const char *protName = Pprotectionnames[protection];
assert(protName);
StringExp *se = new StringExp(e->loc, (char *) protName);
return se->semantic(sc);
}
else if (e->ident == Id::parent)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (s)
{
if (FuncDeclaration *fd = s->isFuncDeclaration()) // Bugzilla 8943
s = fd->toAliasFunc();
if (!s->isImport()) // Bugzilla 8922
s = s->toParent();
}
if (!s || s->isImport())
{
e->error("argument %s has no parent", o->toChars());
goto Lfalse;
}
if (FuncDeclaration *f = s->isFuncDeclaration())
{
if (TemplateDeclaration *td = getFuncTemplateDecl(f))
{
if (td->overroot) // if not start of overloaded list of TemplateDeclaration's
td = td->overroot; // then get the start
Expression *ex = new TemplateExp(e->loc, td, f);
ex = ex->semantic(sc);
return ex;
}
if (FuncLiteralDeclaration *fld = f->isFuncLiteralDeclaration())
{
// Directly translate to VarExp instead of FuncExp
Expression *ex = new VarExp(e->loc, fld, 1);
return ex->semantic(sc);
}
}
return (new DsymbolExp(e->loc, s))->semantic(sc);
}
else if (e->ident == Id::hasMember ||
e->ident == Id::getMember ||
e->ident == Id::getOverloads ||
e->ident == Id::getVirtualMethods ||
e->ident == Id::getVirtualFunctions)
{
if (dim != 2)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Expression *ex = isExpression((*e->args)[1]);
if (!ex)
{
e->error("expression expected as second argument of __traits %s", e->ident->toChars());
goto Lfalse;
}
ex = ex->ctfeInterpret();
StringExp *se = ex->toStringExp();
if (!se || se->length() == 0)
{
e->error("string expected as second argument of __traits %s instead of %s", e->ident->toChars(), ex->toChars());
goto Lfalse;
}
se = se->toUTF8(sc);
if (se->sz != 1)
{
e->error("string must be chars");
goto Lfalse;
}
Identifier *id = Lexer::idPool((char *)se->string);
/* Prefer dsymbol, because it might need some runtime contexts.
*/
Dsymbol *sym = getDsymbol(o);
if (sym)
{
ex = new DsymbolExp(e->loc, sym);
ex = new DotIdExp(e->loc, ex, id);
}
else if (Type *t = isType(o))
ex = typeDotIdExp(e->loc, t, id);
else if (Expression *ex2 = isExpression(o))
ex = new DotIdExp(e->loc, ex2, id);
else
{
e->error("invalid first argument");
goto Lfalse;
}
if (e->ident == Id::hasMember)
{
if (sym)
{
Dsymbol *sm = sym->search(e->loc, id);
if (sm)
goto Ltrue;
}
/* Take any errors as meaning it wasn't found
*/
Scope *sc2 = sc->push();
ex = ex->trySemantic(sc2);
sc2->pop();
if (!ex)
goto Lfalse;
else
goto Ltrue;
}
else if (e->ident == Id::getMember)
{
ex = ex->semantic(sc);
return ex;
}
else if (e->ident == Id::getVirtualFunctions ||
e->ident == Id::getVirtualMethods ||
e->ident == Id::getOverloads)
{
unsigned errors = global.errors;
Expression *eorig = ex;
ex = ex->semantic(sc);
if (errors < global.errors)
e->error("%s cannot be resolved", eorig->toChars());
/* Create tuple of functions of ex
*/
//ex->print();
Expressions *exps = new Expressions();
FuncDeclaration *f;
if (ex->op == TOKvar)
{
VarExp *ve = (VarExp *)ex;
f = ve->var->isFuncDeclaration();
ex = NULL;
}
else if (ex->op == TOKdotvar)
{
DotVarExp *dve = (DotVarExp *)ex;
f = dve->var->isFuncDeclaration();
if (dve->e1->op == TOKdottype || dve->e1->op == TOKthis)
ex = NULL;
else
ex = dve->e1;
}
else
f = NULL;
Ptrait p;
p.exps = exps;
p.e1 = ex;
p.ident = e->ident;
overloadApply(f, &p, &fptraits);
TupleExp *tup = new TupleExp(e->loc, exps);
return tup->semantic(sc);
}
else
assert(0);
}
else if (e->ident == Id::classInstanceSize)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
ClassDeclaration *cd;
if (!s || (cd = s->isClassDeclaration()) == NULL)
{
e->error("first argument is not a class");
goto Lfalse;
}
if (cd->sizeok == SIZEOKnone)
{
if (cd->scope)
cd->semantic(cd->scope);
}
if (cd->sizeok != SIZEOKdone)
{
e->error("%s %s is forward referenced", cd->kind(), cd->toChars());
goto Lfalse;
}
return new IntegerExp(e->loc, cd->structsize, Type::tsize_t);
}
else if (e->ident == Id::getAliasThis)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
AggregateDeclaration *ad;
if (!s || (ad = s->isAggregateDeclaration()) == NULL)
{
e->error("argument is not an aggregate type");
goto Lfalse;
}
Expressions *exps = new Expressions();
if (ad->aliasthis)
exps->push(new StringExp(e->loc, ad->aliasthis->ident->toChars()));
Expression *ex = new TupleExp(e->loc, exps);
ex = ex->semantic(sc);
return ex;
}
else if (e->ident == Id::getAttributes)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (!s)
{
#if 0
Expression *x = isExpression(o);
Type *t = isType(o);
if (x) printf("e = %s %s\n", Token::toChars(x->op), x->toChars());
if (t) printf("t = %d %s\n", t->ty, t->toChars());
#endif
e->error("first argument is not a symbol");
goto Lfalse;
}
//printf("getAttributes %s, attrs = %p, scope = %p\n", s->toChars(), s->userAttributes, s->userAttributesScope);
UserAttributeDeclaration *udad = s->userAttribDecl;
TupleExp *tup = new TupleExp(e->loc, udad ? udad->getAttributes() : new Expressions());
return tup->semantic(sc);
}
else if (e->ident == Id::getFunctionAttributes)
{
/// extract all function attributes as a tuple (const/shared/inout/pure/nothrow/etc) except UDAs.
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
Type *t = isType(o);
TypeFunction *tf = NULL;
if (s)
{
if (FuncDeclaration *f = s->isFuncDeclaration())
t = f->type;
else if (VarDeclaration *v = s->isVarDeclaration())
t = v->type;
}
if (t)
{
if (t->ty == Tfunction)
tf = (TypeFunction *)t;
else if (t->ty == Tdelegate)
tf = (TypeFunction *)t->nextOf();
else if (t->ty == Tpointer && t->nextOf()->ty == Tfunction)
tf = (TypeFunction *)t->nextOf();
}
if (!tf)
{
e->error("first argument is not a function");
goto Lfalse;
}
Expressions *mods = new Expressions();
PushAttributes pa;
pa.mods = mods;
tf->modifiersApply(&pa, &PushAttributes::fp);
tf->attributesApply(&pa, &PushAttributes::fp, TRUSTformatSystem);
TupleExp *tup = new TupleExp(e->loc, mods);
return tup->semantic(sc);
}
else if (e->ident == Id::allMembers || e->ident == Id::derivedMembers)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
ScopeDsymbol *sds;
if (!s)
{
e->error("argument has no members");
goto Lfalse;
}
Import *import;
if ((import = s->isImport()) != NULL)
{
// Bugzilla 9692
sds = import->mod;
}
else if ((sds = s->isScopeDsymbol()) == NULL)
{
e->error("%s %s has no members", s->kind(), s->toChars());
goto Lfalse;
}
// use a struct as local function
struct PushIdentsDg
{
static int dg(void *ctx, size_t n, Dsymbol *sm)
{
if (!sm)
return 1;
//printf("\t[%i] %s %s\n", i, sm->kind(), sm->toChars());
if (sm->ident)
{
if (sm->ident != Id::ctor &&
sm->ident != Id::dtor &&
sm->ident != Id::_postblit &&
memcmp(sm->ident->string, "__", 2) == 0)
{
return 0;
}
//printf("\t%s\n", sm->ident->toChars());
Identifiers *idents = (Identifiers *)ctx;
/* Skip if already present in idents[]
*/
for (size_t j = 0; j < idents->dim; j++)
{ Identifier *id = (*idents)[j];
if (id == sm->ident)
return 0;
#ifdef DEBUG
// Avoid using strcmp in the first place due to the performance impact in an O(N^2) loop.
assert(strcmp(id->toChars(), sm->ident->toChars()) != 0);
#endif
}
idents->push(sm->ident);
}
else
{
EnumDeclaration *ed = sm->isEnumDeclaration();
if (ed)
{
ScopeDsymbol::foreach(NULL, ed->members, &PushIdentsDg::dg, (Identifiers *)ctx);
}
}
return 0;
}
};
Identifiers *idents = new Identifiers;
ScopeDsymbol::foreach(sc, sds->members, &PushIdentsDg::dg, idents);
ClassDeclaration *cd = sds->isClassDeclaration();
if (cd && e->ident == Id::allMembers)
{
struct PushBaseMembers
{
static void dg(ClassDeclaration *cd, Identifiers *idents)
{
for (size_t i = 0; i < cd->baseclasses->dim; i++)
{
ClassDeclaration *cb = (*cd->baseclasses)[i]->base;
ScopeDsymbol::foreach(NULL, cb->members, &PushIdentsDg::dg, idents);
if (cb->baseclasses->dim)
dg(cb, idents);
}
}
};
PushBaseMembers::dg(cd, idents);
}
// Turn Identifiers into StringExps reusing the allocated array
assert(sizeof(Expressions) == sizeof(Identifiers));
Expressions *exps = (Expressions *)idents;
for (size_t i = 0; i < idents->dim; i++)
{
Identifier *id = (*idents)[i];
StringExp *se = new StringExp(e->loc, id->toChars());
(*exps)[i] = se;
}
/* Making this a tuple is more flexible, as it can be statically unrolled.
* To make an array literal, enclose __traits in [ ]:
* [ __traits(allMembers, ...) ]
*/
Expression *ex = new TupleExp(e->loc, exps);
ex = ex->semantic(sc);
return ex;
}
else if (e->ident == Id::compiles)
{
/* Determine if all the objects - types, expressions, or symbols -
* compile without error
*/
if (!dim)
goto Lfalse;
for (size_t i = 0; i < dim; i++)
{
unsigned errors = global.startGagging();
unsigned oldspec = global.speculativeGag;
global.speculativeGag = global.gag;
Scope *sc2 = sc->push();
sc2->speculative = true;
sc2->flags = sc->flags & ~SCOPEctfe | SCOPEcompile;
bool err = false;
RootObject *o = (*e->args)[i];
Type *t = isType(o);
Expression *ex = t ? t->toExpression() : isExpression(o);
if (!ex && t)
{
Dsymbol *s;
t->resolve(e->loc, sc2, &ex, &t, &s);
if (t)
{
t->semantic(e->loc, sc2);
if (t->ty == Terror)
err = true;
}
else if (s && s->errors)
err = true;
}
if (ex)
{
ex = ex->semantic(sc2);
ex = resolvePropertiesOnly(sc2, ex);
ex = ex->optimize(WANTvalue);
ex = checkGC(sc2, ex);
if (ex->op == TOKerror)
err = true;
}
sc2->pop();
global.speculativeGag = oldspec;
if (global.endGagging(errors) || err)
{
goto Lfalse;
}
}
goto Ltrue;
}
else if (e->ident == Id::isSame)
{
/* Determine if two symbols are the same
*/
if (dim != 2)
goto Ldimerror;
if (!TemplateInstance::semanticTiargs(e->loc, sc, e->args, 0))
return new ErrorExp();
RootObject *o1 = (*e->args)[0];
RootObject *o2 = (*e->args)[1];
Dsymbol *s1 = getDsymbol(o1);
Dsymbol *s2 = getDsymbol(o2);
//printf("isSame: %s, %s\n", o1->toChars(), o2->toChars());
#if 0
printf("o1: %p\n", o1);
printf("o2: %p\n", o2);
if (!s1)
{
Expression *ea = isExpression(o1);
if (ea)
printf("%s\n", ea->toChars());
Type *ta = isType(o1);
if (ta)
printf("%s\n", ta->toChars());
goto Lfalse;
}
else
printf("%s %s\n", s1->kind(), s1->toChars());
#endif
if (!s1 && !s2)
{
Expression *ea1 = isExpression(o1);
Expression *ea2 = isExpression(o2);
if (ea1 && ea2)
{
if (ea1->equals(ea2))
goto Ltrue;
}
}
if (!s1 || !s2)
goto Lfalse;
s1 = s1->toAlias();
s2 = s2->toAlias();
if (s1->isFuncAliasDeclaration())
s1 = ((FuncAliasDeclaration *)s1)->toAliasFunc();
if (s2->isFuncAliasDeclaration())
s2 = ((FuncAliasDeclaration *)s2)->toAliasFunc();
if (s1 == s2)
goto Ltrue;
else
goto Lfalse;
}
else if (e->ident == Id::getUnitTests)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
if (!s)
{
e->error("argument %s to __traits(getUnitTests) must be a module or aggregate", o->toChars());
goto Lfalse;
}
Import *imp = s->isImport();
if (imp) // Bugzilla 10990
s = imp->mod;
ScopeDsymbol* scope = s->isScopeDsymbol();
if (!scope)
{
e->error("argument %s to __traits(getUnitTests) must be a module or aggregate, not a %s", s->toChars(), s->kind());
goto Lfalse;
}
Expressions* unitTests = new Expressions();
Dsymbols* symbols = scope->members;
if (global.params.useUnitTests && symbols)
{
// Should actually be a set
AA* uniqueUnitTests = NULL;
collectUnitTests(symbols, uniqueUnitTests, unitTests);
}
TupleExp *tup = new TupleExp(e->loc, unitTests);
return tup->semantic(sc);
}
else if(e->ident == Id::getVirtualIndex)
{
if (dim != 1)
goto Ldimerror;
RootObject *o = (*e->args)[0];
Dsymbol *s = getDsymbol(o);
FuncDeclaration *fd;
if (!s || (fd = s->isFuncDeclaration()) == NULL)
{
e->error("first argument to __traits(getVirtualIndex) must be a function");
goto Lfalse;
}
fd = fd->toAliasFunc(); // Neccessary to support multiple overloads.
return new IntegerExp(e->loc, fd->vtblIndex, Type::tptrdiff_t);
}
else
{
if (const char *sub = (const char *)speller(e->ident->toChars(), &trait_search_fp, NULL, idchars))
e->error("unrecognized trait '%s', did you mean '%s'?", e->ident->toChars(), sub);
else
e->error("unrecognized trait '%s'", e->ident->toChars());
goto Lfalse;
}
return NULL;
Ldimerror:
e->error("wrong number of arguments %d", (int)dim);
goto Lfalse;
Lfalse:
return new IntegerExp(e->loc, 0, Type::tbool);
Ltrue:
return new IntegerExp(e->loc, 1, Type::tbool);
}
elem *getEthis(Loc loc, IRState *irs, Dsymbol *fd)
{
elem *ethis;
FuncDeclaration *thisfd = irs->getFunc();
Dsymbol *fdparent = fd->toParent2();
//printf("getEthis(thisfd = '%s', fd = '%s', fdparent = '%s')\n", thisfd->toPrettyChars(), fd->toPrettyChars(), fdparent->toPrettyChars());
if (fdparent == thisfd ||
/* These two are compiler generated functions for the in and out contracts,
* and are called from an overriding function, not just the one they're
* nested inside, so this hack is so they'll pass
*/
fd->ident == Id::require || fd->ident == Id::ensure)
{ /* Going down one nesting level, i.e. we're calling
* a nested function from its enclosing function.
*/
#if DMDV2
if (irs->sclosure)
ethis = el_var(irs->sclosure);
else
#endif
if (irs->sthis)
{ // We have a 'this' pointer for the current function
ethis = el_var(irs->sthis);
/* If no variables in the current function's frame are
* referenced by nested functions, then we can 'skip'
* adding this frame into the linked list of stack
* frames.
*/
if (thisfd->hasNestedFrameRefs())
{ /* Local variables are referenced, can't skip.
* Address of 'this' gives the 'this' for the nested
* function
*/
ethis = el_una(OPaddr, TYnptr, ethis);
}
}
else
{ /* No 'this' pointer for current function,
* use NULL if no references to the current function's frame
*/
ethis = el_long(TYnptr, 0);
if (thisfd->hasNestedFrameRefs())
{ /* OPframeptr is an operator that gets the frame pointer
* for the current function, i.e. for the x86 it gets
* the value of EBP
*/
ethis->Eoper = OPframeptr;
}
}
//if (fdparent != thisfd) ethis = el_bin(OPadd, TYnptr, ethis, el_long(TYint, 0x18));
}
else
{
if (!irs->sthis) // if no frame pointer for this function
{
fd->error(loc, "is a nested function and cannot be accessed from %s", irs->getFunc()->toPrettyChars());
ethis = el_long(TYnptr, 0); // error recovery
}
else
{
ethis = el_var(irs->sthis);
Dsymbol *s = thisfd;
while (fd != s)
{ /* Go up a nesting level, i.e. we need to find the 'this'
* of an enclosing function.
* Our 'enclosing function' may also be an inner class.
*/
//printf("\ts = '%s'\n", s->toChars());
thisfd = s->isFuncDeclaration();
if (thisfd)
{ /* Enclosing function is a function.
*/
if (fdparent == s->toParent2())
break;
if (thisfd->isNested())
{
FuncDeclaration *p = s->toParent2()->isFuncDeclaration();
if (!p || p->hasNestedFrameRefs())
ethis = el_una(OPind, TYnptr, ethis);
}
else if (thisfd->vthis)
{
}
else
{ // Error should have been caught by front end
assert(0);
}
}
else
{ /* Enclosed by an aggregate. That means the current
* function must be a member function of that aggregate.
*/
ClassDeclaration *cd;
StructDeclaration *sd;
AggregateDeclaration *ad = s->isAggregateDeclaration();
if (!ad)
goto Lnoframe;
cd = s->isClassDeclaration();
if (cd && fd->isClassDeclaration() &&
fd->isClassDeclaration()->isBaseOf(cd, NULL))
break;
sd = s->isStructDeclaration();
if (fd == sd)
break;
if (!ad->isNested() || !ad->vthis)
{
Lnoframe:
irs->getFunc()->error(loc, "cannot get frame pointer to %s", fd->toChars());
return el_long(TYnptr, 0); // error recovery
}
ethis = el_bin(OPadd, TYnptr, ethis, el_long(TYsize_t, ad->vthis->offset));
ethis = el_una(OPind, TYnptr, ethis);
if (fdparent == s->toParent2())
break;
if (fd == s->toParent2())
{
/* Remember that frames for functions that have no
* nested references are skipped in the linked list
* of frames.
*/
if (s->toParent2()->isFuncDeclaration()->hasNestedFrameRefs())
ethis = el_una(OPind, TYnptr, ethis);
break;
}
if (s->toParent2()->isFuncDeclaration())
{
/* Remember that frames for functions that have no
* nested references are skipped in the linked list
* of frames.
*/
if (s->toParent2()->isFuncDeclaration()->hasNestedFrameRefs())
ethis = el_una(OPind, TYnptr, ethis);
}
}
s = s->toParent2();
assert(s);
}
}
}
#if 0
printf("ethis:\n");
elem_print(ethis);
printf("\n");
#endif
return ethis;
}
Expression *TraitsExp::semantic(Scope *sc)
{
#if LOGSEMANTIC
printf("TraitsExp::semantic() %s\n", toChars());
#endif
if (ident != Id::compiles && ident != Id::isSame)
TemplateInstance::semanticTiargs(loc, sc, args, 1);
size_t dim = args ? args->dim : 0;
Object *o;
FuncDeclaration *f;
#define ISTYPE(cond) \
for (size_t i = 0; i < dim; i++) \
{ Type *t = getType((Object *)args->data[i]); \
if (!t) \
goto Lfalse; \
if (!(cond)) \
goto Lfalse; \
} \
if (!dim) \
goto Lfalse; \
goto Ltrue;
#define ISDSYMBOL(cond) \
for (size_t i = 0; i < dim; i++) \
{ Dsymbol *s = getDsymbol((Object *)args->data[i]); \
if (!s) \
goto Lfalse; \
if (!(cond)) \
goto Lfalse; \
} \
if (!dim) \
goto Lfalse; \
goto Ltrue;
if (ident == Id::isArithmetic)
{
ISTYPE(t->isintegral() || t->isfloating())
}
else if (ident == Id::isFloating)
{
ISTYPE(t->isfloating())
}
else if (ident == Id::isIntegral)
{
ISTYPE(t->isintegral())
}
else if (ident == Id::isScalar)
{
ISTYPE(t->isscalar())
}
else if (ident == Id::isUnsigned)
{
ISTYPE(t->isunsigned())
}
else if (ident == Id::isAssociativeArray)
{
ISTYPE(t->toBasetype()->ty == Taarray)
}
else if (ident == Id::isStaticArray)
{
ISTYPE(t->toBasetype()->ty == Tsarray)
}
else if (ident == Id::isAbstractClass)
{
ISTYPE(t->toBasetype()->ty == Tclass && ((TypeClass *)t->toBasetype())->sym->isAbstract())
}
else if (ident == Id::isFinalClass)
{
ISTYPE(t->toBasetype()->ty == Tclass && ((TypeClass *)t->toBasetype())->sym->storage_class & STCfinal)
}
else if (ident == Id::isAbstractFunction)
{
ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && f->isAbstract())
}
else if (ident == Id::isVirtualFunction)
{
ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && f->isVirtual())
}
else if (ident == Id::isFinalFunction)
{
ISDSYMBOL((f = s->isFuncDeclaration()) != NULL && f->isFinal())
}
else if (ident == Id::hasMember ||
ident == Id::getMember ||
ident == Id::getVirtualFunctions)
{
if (dim != 2)
goto Ldimerror;
Object *o = (Object *)args->data[0];
Expression *e = isExpression((Object *)args->data[1]);
if (!e)
{ // error("expression expected as second argument of __traits %s", ident->toChars());
goto Lfalse;
}
e = e->optimize(WANTvalue | WANTinterpret);
if (e->op != TOKstring)
{ // error("string expected as second argument of __traits %s instead of %s", ident->toChars(), e->toChars());
goto Lfalse;
}
StringExp *se = (StringExp *)e;
se = se->toUTF8(sc);
if (se->sz != 1)
{ // error("string must be chars");
goto Lfalse;
}
Identifier *id = Lexer::idPool((char *)se->string);
Type *t = isType(o);
e = isExpression(o);
Dsymbol *s = isDsymbol(o);
if (t)
e = new TypeDotIdExp(loc, t, id);
else if (e)
e = new DotIdExp(loc, e, id);
else if (s)
{ e = new DsymbolExp(loc, s);
e = new DotIdExp(loc, e, id);
}
else
{ // error("invalid first argument");
goto Lfalse;
}
if (ident == Id::hasMember)
{ /* Take any errors as meaning it wasn't found
*/
unsigned errors = global.errors;
global.gag++;
e = e->semantic(sc);
global.gag--;
if (errors != global.errors)
{ if (global.gag == 0)
global.errors = errors;
goto Lfalse;
}
else
goto Ltrue;
}
else if (ident == Id::getMember)
{
e = e->semantic(sc);
return e;
}
else if (ident == Id::getVirtualFunctions)
{
unsigned errors = global.errors;
Expression *ex = e;
e = e->semantic(sc);
/* if (errors < global.errors)
error("%s cannot be resolved", ex->toChars()); */
/* Create tuple of virtual function overloads of e
*/
//e->dump(0);
Expressions *exps = new Expressions();
FuncDeclaration *f;
if (e->op == TOKvar)
{ VarExp *ve = (VarExp *)e;
f = ve->var->isFuncDeclaration();
}
else if (e->op == TOKdotvar)
{ DotVarExp *dve = (DotVarExp *)e;
f = dve->var->isFuncDeclaration();
}
else
f = NULL;
Pvirtuals p;
p.exps = exps;
p.e1 = e;
overloadApply(f, fpvirtuals, &p);
TupleExp *tup = new TupleExp(loc, exps);
return tup->semantic(sc);
}
else
assert(0);
}
else if (ident == Id::classInstanceSize)
{
if (dim != 1)
goto Ldimerror;
Object *o = (Object *)args->data[0];
Dsymbol *s = getDsymbol(o);
ClassDeclaration *cd;
if (!s || (cd = s->isClassDeclaration()) == NULL)
{
// error("first argument is not a class");
goto Lfalse;
}
return new IntegerExp(loc, cd->structsize, Type::tsize_t);
}
else if (ident == Id::allMembers || ident == Id::derivedMembers)
{
if (dim != 1)
goto Ldimerror;
Object *o = (Object *)args->data[0];
Dsymbol *s = getDsymbol(o);
ScopeDsymbol *sd;
if (!s)
{
// error("argument has no members");
goto Lfalse;
}
if ((sd = s->isScopeDsymbol()) == NULL)
{
// error("%s %s has no members", s->kind(), s->toChars());
goto Lfalse;
}
Expressions *exps = new Expressions;
while (1)
{ size_t dim = ScopeDsymbol::dim(sd->members);
for (size_t i = 0; i < dim; i++)
{
Dsymbol *sm = ScopeDsymbol::getNth(sd->members, i);
//printf("\t[%i] %s %s\n", i, sm->kind(), sm->toChars());
if (sm->ident)
{
//printf("\t%s\n", sm->ident->toChars());
char *str = sm->ident->toChars();
/* Skip if already present in exps[]
*/
for (size_t j = 0; j < exps->dim; j++)
{ StringExp *se2 = (StringExp *)exps->data[j];
if (strcmp(str, (char *)se2->string) == 0)
goto Lnext;
}
StringExp *se = new StringExp(loc, str);
exps->push(se);
}
Lnext:
;
}
ClassDeclaration *cd = sd->isClassDeclaration();
if (cd && cd->baseClass && ident == Id::allMembers)
sd = cd->baseClass; // do again with base class
else
break;
}
Expression *e = new ArrayLiteralExp(loc, exps);
e = e->semantic(sc);
return e;
}
else if (ident == Id::compiles)
{
/* Determine if all the objects - types, expressions, or symbols -
* compile without error
*/
if (!dim)
goto Lfalse;
for (size_t i = 0; i < dim; i++)
{ Object *o = (Object *)args->data[i];
Type *t;
Expression *e;
Dsymbol *s;
unsigned errors = global.errors;
global.gag++;
t = isType(o);
if (t)
{ t->resolve(loc, sc, &e, &t, &s);
if (t)
t->semantic(loc, sc);
else if (e)
e->semantic(sc);
}
else
{ e = isExpression(o);
if (e)
e->semantic(sc);
}
global.gag--;
if (errors != global.errors)
{ if (global.gag == 0)
global.errors = errors;
goto Lfalse;
}
}
goto Ltrue;
}
else if (ident == Id::isSame)
{ /* Determine if two symbols are the same
*/
if (dim != 2)
goto Ldimerror;
TemplateInstance::semanticTiargs(loc, sc, args, 0);
Object *o1 = (Object *)args->data[0];
Object *o2 = (Object *)args->data[1];
Dsymbol *s1 = getDsymbol(o1);
Dsymbol *s2 = getDsymbol(o2);
#if 0
printf("o1: %p\n", o1);
printf("o2: %p\n", o2);
if (!s1)
{ Expression *ea = isExpression(o1);
if (ea)
printf("%s\n", ea->toChars());
Type *ta = isType(o1);
if (ta)
printf("%s\n", ta->toChars());
goto Lfalse;
}
else
printf("%s %s\n", s1->kind(), s1->toChars());
#endif
if (!s1 && !s2)
{ Expression *ea1 = isExpression(o1);
Expression *ea2 = isExpression(o2);
if (ea1 && ea2 && ea1->equals(ea2))
goto Ltrue;
}
if (!s1 || !s2)
goto Lfalse;
s1 = s1->toAlias();
s2 = s2->toAlias();
if (s1 == s2)
goto Ltrue;
else
goto Lfalse;
}
else
{ // error("unrecognized trait %s", ident->toChars());
goto Lfalse;
}
return NULL;
Lnottype:
// error("%s is not a type", o->toChars());
goto Lfalse;
Ldimerror:
// error("wrong number of arguments %d", dim);
goto Lfalse;
Lfalse:
return new IntegerExp(loc, 0, Type::tbool);
Ltrue:
return new IntegerExp(loc, 1, Type::tbool);
}
void ClassDeclaration::semantic(Scope *sc)
{
//printf("ClassDeclaration::semantic(%s), type = %p, sizeok = %d, this = %p\n", toChars(), type, sizeok, this);
//printf("\tparent = %p, '%s'\n", sc->parent, sc->parent ? sc->parent->toChars() : "");
//printf("sc->stc = %x\n", sc->stc);
//{ static int n; if (++n == 20) *(char*)0=0; }
if (!ident) // if anonymous class
{ const char *id = "__anonclass";
ident = Identifier::generateId(id);
}
if (!sc)
sc = scope;
if (!parent && sc->parent && !sc->parent->isModule())
parent = sc->parent;
type = type->semantic(loc, sc);
handle = type;
if (!members) // if forward reference
{ //printf("\tclass '%s' is forward referenced\n", toChars());
return;
}
if (symtab)
{ if (sizeok == 1 || !scope)
{ //printf("\tsemantic for '%s' is already completed\n", toChars());
return; // semantic() already completed
}
}
else
symtab = new DsymbolTable();
Scope *scx = NULL;
if (scope)
{ sc = scope;
scx = scope; // save so we don't make redundant copies
scope = NULL;
}
unsigned dprogress_save = Module::dprogress;
#ifdef IN_GCC
if (attributes)
attributes->append(sc->attributes);
else
attributes = sc->attributes;
methods.setDim(0);
#endif
if (sc->stc & STCdeprecated)
{
isdeprecated = 1;
}
// Expand any tuples in baseclasses[]
for (size_t i = 0; i < baseclasses->dim; )
{ BaseClass *b = (BaseClass *)baseclasses->data[i];
b->type = b->type->semantic(loc, sc);
Type *tb = b->type->toBasetype();
if (tb->ty == Ttuple)
{ TypeTuple *tup = (TypeTuple *)tb;
enum PROT protection = b->protection;
baseclasses->remove(i);
size_t dim = Parameter::dim(tup->arguments);
for (size_t j = 0; j < dim; j++)
{ Parameter *arg = Parameter::getNth(tup->arguments, j);
b = new BaseClass(arg->type, protection);
baseclasses->insert(i + j, b);
}
}
else
i++;
}
// See if there's a base class as first in baseclasses[]
if (baseclasses->dim)
{ TypeClass *tc;
BaseClass *b;
Type *tb;
b = (BaseClass *)baseclasses->data[0];
//b->type = b->type->semantic(loc, sc);
tb = b->type->toBasetype();
if (tb->ty != Tclass)
{ error("base type must be class or interface, not %s", b->type->toChars());
baseclasses->remove(0);
}
else
{
tc = (TypeClass *)(tb);
if (tc->sym->isDeprecated())
{
if (!isDeprecated())
{
// Deriving from deprecated class makes this one deprecated too
isdeprecated = 1;
tc->checkDeprecated(loc, sc);
}
}
if (tc->sym->isInterfaceDeclaration())
;
else
{
for (ClassDeclaration *cdb = tc->sym; cdb; cdb = cdb->baseClass)
{
if (cdb == this)
{
error("circular inheritance");
baseclasses->remove(0);
goto L7;
}
}
if (!tc->sym->symtab || tc->sym->sizeok == 0)
{ // Try to resolve forward reference
if (/*sc->mustsemantic &&*/ tc->sym->scope)
tc->sym->semantic(NULL);
}
if (!tc->sym->symtab || tc->sym->scope || tc->sym->sizeok == 0)
{
//printf("%s: forward reference of base class %s\n", toChars(), tc->sym->toChars());
//error("forward reference of base class %s", baseClass->toChars());
// Forward reference of base class, try again later
//printf("\ttry later, forward reference of base class %s\n", tc->sym->toChars());
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
if (tc->sym->scope)
tc->sym->scope->module->addDeferredSemantic(tc->sym);
scope->module->addDeferredSemantic(this);
return;
}
else
{ baseClass = tc->sym;
b->base = baseClass;
}
L7: ;
}
}
}
// Treat the remaining entries in baseclasses as interfaces
// Check for errors, handle forward references
for (size_t i = (baseClass ? 1 : 0); i < baseclasses->dim; )
{ TypeClass *tc;
BaseClass *b;
Type *tb;
b = (BaseClass *)baseclasses->data[i];
b->type = b->type->semantic(loc, sc);
tb = b->type->toBasetype();
if (tb->ty == Tclass)
tc = (TypeClass *)tb;
else
tc = NULL;
if (!tc || !tc->sym->isInterfaceDeclaration())
{
error("base type must be interface, not %s", b->type->toChars());
baseclasses->remove(i);
continue;
}
else
{
if (tc->sym->isDeprecated())
{
if (!isDeprecated())
{
// Deriving from deprecated class makes this one deprecated too
isdeprecated = 1;
tc->checkDeprecated(loc, sc);
}
}
// Check for duplicate interfaces
for (size_t j = (baseClass ? 1 : 0); j < i; j++)
{
BaseClass *b2 = (BaseClass *)baseclasses->data[j];
if (b2->base == tc->sym)
error("inherits from duplicate interface %s", b2->base->toChars());
}
if (!tc->sym->symtab)
{ // Try to resolve forward reference
if (/*sc->mustsemantic &&*/ tc->sym->scope)
tc->sym->semantic(NULL);
}
b->base = tc->sym;
if (!b->base->symtab || b->base->scope)
{
//error("forward reference of base class %s", baseClass->toChars());
// Forward reference of base, try again later
//printf("\ttry later, forward reference of base %s\n", baseClass->toChars());
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
if (tc->sym->scope)
tc->sym->scope->module->addDeferredSemantic(tc->sym);
scope->module->addDeferredSemantic(this);
return;
}
}
i++;
}
// If no base class, and this is not an Object, use Object as base class
if (!baseClass && ident != Id::Object)
{
// BUG: what if Object is redefined in an inner scope?
Type *tbase = new TypeIdentifier(0, Id::Object);
BaseClass *b;
TypeClass *tc;
Type *bt;
if (!object)
{
error("missing or corrupt object.d");
fatal();
}
bt = tbase->semantic(loc, sc)->toBasetype();
b = new BaseClass(bt, PROTpublic);
baseclasses->shift(b);
assert(b->type->ty == Tclass);
tc = (TypeClass *)(b->type);
baseClass = tc->sym;
assert(!baseClass->isInterfaceDeclaration());
b->base = baseClass;
}
interfaces_dim = baseclasses->dim;
interfaces = (BaseClass **)baseclasses->data;
if (baseClass)
{
if (baseClass->storage_class & STCfinal)
error("cannot inherit from final class %s", baseClass->toChars());
interfaces_dim--;
interfaces++;
// Copy vtbl[] from base class
vtbl.setDim(baseClass->vtbl.dim);
memcpy(vtbl.data, baseClass->vtbl.data, sizeof(void *) * vtbl.dim);
// Inherit properties from base class
com = baseClass->isCOMclass();
isscope = baseClass->isscope;
vthis = baseClass->vthis;
}
else
{
// No base class, so this is the root of the class hierarchy
vtbl.setDim(0);
vtbl.push(this); // leave room for classinfo as first member
}
protection = sc->protection;
storage_class |= sc->stc;
if (sizeok == 0)
{
interfaceSemantic(sc);
for (size_t i = 0; i < members->dim; i++)
{
Dsymbol *s = (Dsymbol *)members->data[i];
s->addMember(sc, this, 1);
}
/* If this is a nested class, add the hidden 'this'
* member which is a pointer to the enclosing scope.
*/
if (vthis) // if inheriting from nested class
{ // Use the base class's 'this' member
isnested = 1;
if (storage_class & STCstatic)
error("static class cannot inherit from nested class %s", baseClass->toChars());
if (toParent2() != baseClass->toParent2())
{
if (toParent2())
{
error("is nested within %s, but super class %s is nested within %s",
toParent2()->toChars(),
baseClass->toChars(),
baseClass->toParent2()->toChars());
}
else
{
error("is not nested, but super class %s is nested within %s",
baseClass->toChars(),
baseClass->toParent2()->toChars());
}
isnested = 0;
}
}
else if (!(storage_class & STCstatic))
{ Dsymbol *s = toParent2();
if (s)
{
AggregateDeclaration *ad = s->isClassDeclaration();
FuncDeclaration *fd = s->isFuncDeclaration();
if (ad || fd)
{ isnested = 1;
Type *t;
if (ad)
t = ad->handle;
else if (fd)
{ AggregateDeclaration *ad2 = fd->isMember2();
if (ad2)
t = ad2->handle;
else
{
t = new TypePointer(Type::tvoid);
t = t->semantic(0, sc);
}
}
else
assert(0);
assert(!vthis);
vthis = new ThisDeclaration(loc, t);
members->push(vthis);
}
}
}
}
if (storage_class & STCauto)
error("storage class 'auto' is invalid when declaring a class, did you mean to use 'scope'?");
if (storage_class & STCscope)
isscope = 1;
if (storage_class & STCabstract)
isabstract = 1;
sc = sc->push(this);
sc->stc &= STCsafe | STCtrusted | STCsystem;
#if IN_GCC
sc->attributes = NULL;
#endif
sc->parent = this;
sc->inunion = 0;
if (isCOMclass())
{
#if _WIN32
sc->linkage = LINKwindows;
#else
/* This enables us to use COM objects under Linux and
* work with things like XPCOM
*/
sc->linkage = LINKc;
#endif
}
sc->protection = PROTpublic;
sc->explicitProtection = 0;
sc->structalign = 8;
structalign = sc->structalign;
if (baseClass)
{ sc->offset = baseClass->structsize;
alignsize = baseClass->alignsize;
// if (isnested)
// sc->offset += PTRSIZE; // room for uplevel context pointer
}
else
{ sc->offset = PTRSIZE * 2; // allow room for __vptr and __monitor
alignsize = PTRSIZE;
}
structsize = sc->offset;
Scope scsave = *sc;
size_t members_dim = members->dim;
sizeok = 0;
/* Set scope so if there are forward references, we still might be able to
* resolve individual members like enums.
*/
for (size_t i = 0; i < members_dim; i++)
{ Dsymbol *s = (Dsymbol *)members->data[i];
/* There are problems doing this in the general case because
* Scope keeps track of things like 'offset'
*/
if (s->isEnumDeclaration() || (s->isAggregateDeclaration() && s->ident))
{
//printf("setScope %s %s\n", s->kind(), s->toChars());
s->setScope(sc);
}
}
for (size_t i = 0; i < members_dim; i++)
{ Dsymbol *s = (Dsymbol *)members->data[i];
s->semantic(sc);
}
if (sizeok == 2)
{ // semantic() failed because of forward references.
// Unwind what we did, and defer it for later
fields.setDim(0);
structsize = 0;
alignsize = 0;
structalign = 0;
sc = sc->pop();
scope = scx ? scx : new Scope(*sc);
scope->setNoFree();
scope->module->addDeferredSemantic(this);
Module::dprogress = dprogress_save;
//printf("\tsemantic('%s') failed due to forward references\n", toChars());
return;
}
//printf("\tsemantic('%s') successful\n", toChars());
structsize = sc->offset;
//members->print();
/* Look for special member functions.
* They must be in this class, not in a base class.
*/
ctor = (CtorDeclaration *)search(0, Id::ctor, 0);
if (ctor && (ctor->toParent() != this || !ctor->isCtorDeclaration()))
ctor = NULL;
// dtor = (DtorDeclaration *)search(Id::dtor, 0);
// if (dtor && dtor->toParent() != this)
// dtor = NULL;
// inv = (InvariantDeclaration *)search(Id::classInvariant, 0);
// if (inv && inv->toParent() != this)
// inv = NULL;
// Can be in base class
aggNew = (NewDeclaration *)search(0, Id::classNew, 0);
aggDelete = (DeleteDeclaration *)search(0, Id::classDelete, 0);
// If this class has no constructor, but base class does, create
// a constructor:
// this() { }
if (!ctor && baseClass && baseClass->ctor)
{
//printf("Creating default this(){} for class %s\n", toChars());
CtorDeclaration *ctor = new CtorDeclaration(loc, 0, NULL, 0);
ctor->fbody = new CompoundStatement(0, new Statements());
members->push(ctor);
ctor->addMember(sc, this, 1);
*sc = scsave; // why? What about sc->nofree?
sc->offset = structsize;
ctor->semantic(sc);
this->ctor = ctor;
defaultCtor = ctor;
}
#if 0
if (baseClass)
{ if (!aggDelete)
aggDelete = baseClass->aggDelete;
if (!aggNew)
aggNew = baseClass->aggNew;
}
#endif
// Allocate instance of each new interface
for (size_t i = 0; i < vtblInterfaces->dim; i++)
{
BaseClass *b = (BaseClass *)vtblInterfaces->data[i];
unsigned thissize = PTRSIZE;
alignmember(structalign, thissize, &sc->offset);
assert(b->offset == 0);
b->offset = sc->offset;
// Take care of single inheritance offsets
while (b->baseInterfaces_dim)
{
b = &b->baseInterfaces[0];
b->offset = sc->offset;
}
sc->offset += thissize;
if (alignsize < thissize)
alignsize = thissize;
}
structsize = sc->offset;
sizeok = 1;
Module::dprogress++;
dtor = buildDtor(sc);
sc->pop();
#if 0 // Do not call until toObjfile() because of forward references
// Fill in base class vtbl[]s
for (i = 0; i < vtblInterfaces->dim; i++)
{
BaseClass *b = (BaseClass *)vtblInterfaces->data[i];
//b->fillVtbl(this, &b->vtbl, 1);
}
#endif
//printf("-ClassDeclaration::semantic(%s), type = %p\n", toChars(), type);
}
void DtoCreateNestedContext(FuncDeclaration* fd) {
Logger::println("DtoCreateNestedContext for %s", fd->toChars());
LOG_SCOPE
DtoCreateNestedContextType(fd);
if (nestedCtx == NCArray) {
// construct nested variables array
if (!fd->nestedVars.empty())
{
Logger::println("has nested frame");
// start with adding all enclosing parent frames until a static parent is reached
int nparelems = 0;
if (!fd->isStatic())
{
Dsymbol* par = fd->toParent2();
while (par)
{
if (FuncDeclaration* parfd = par->isFuncDeclaration())
{
nparelems += parfd->nestedVars.size();
// stop at first static
if (parfd->isStatic())
break;
}
else if (par->isClassDeclaration())
{
// nothing needed
}
else
{
break;
}
par = par->toParent2();
}
}
int nelems = fd->nestedVars.size() + nparelems;
// make array type for nested vars
LLType* nestedVarsTy = LLArrayType::get(getVoidPtrType(), nelems);
// alloca it
// FIXME align ?
LLValue* nestedVars = DtoRawAlloca(nestedVarsTy, 0, ".nested_vars");
IrFunction* irfunction = fd->ir.irFunc;
// copy parent frame into beginning
if (nparelems)
{
LLValue* src = irfunction->nestArg;
if (!src)
{
assert(irfunction->thisArg);
assert(fd->isMember2());
LLValue* thisval = DtoLoad(irfunction->thisArg);
ClassDeclaration* cd = fd->isMember2()->isClassDeclaration();
assert(cd);
assert(cd->vthis);
src = DtoLoad(DtoGEPi(thisval, 0,cd->vthis->ir.irField->index, ".vthis"));
} else {
src = DtoLoad(src);
}
DtoMemCpy(nestedVars, src, DtoConstSize_t(nparelems*PTRSIZE),
getABITypeAlign(getVoidPtrType()));
}
// store in IrFunction
irfunction->nestedVar = nestedVars;
// go through all nested vars and assign indices
int idx = nparelems;
for (std::set<VarDeclaration*>::iterator i=fd->nestedVars.begin(); i!=fd->nestedVars.end(); ++i)
{
VarDeclaration* vd = *i;
if (!vd->ir.irLocal)
vd->ir.irLocal = new IrLocal(vd);
if (vd->isParameter())
{
Logger::println("nested param: %s", vd->toChars());
LLValue* gep = DtoGEPi(nestedVars, 0, idx);
LLValue* val = DtoBitCast(vd->ir.irLocal->value, getVoidPtrType());
DtoAlignedStore(val, gep);
}
else
{
Logger::println("nested var: %s", vd->toChars());
}
vd->ir.irLocal->nestedIndex = idx++;
}
}
}
else if (nestedCtx == NCHybrid) {
// construct nested variables array
if (!fd->nestedVars.empty())
{
IrFunction* irfunction = fd->ir.irFunc;
unsigned depth = irfunction->depth;
LLStructType *frameType = irfunction->frameType;
// Create frame for current function and append to frames list
// FIXME: alignment ?
LLValue* frame = 0;
#if DMDV2
if (fd->needsClosure())
frame = DtoGcMalloc(frameType, ".frame");
else
#endif
frame = DtoRawAlloca(frameType, 0, ".frame");
// copy parent frames into beginning
if (depth != 0) {
LLValue* src = irfunction->nestArg;
if (!src) {
assert(irfunction->thisArg);
assert(fd->isMember2());
LLValue* thisval = DtoLoad(irfunction->thisArg);
#if DMDV2
AggregateDeclaration* cd = fd->isMember2();
#else
ClassDeclaration* cd = fd->isMember2()->isClassDeclaration();
#endif
assert(cd);
assert(cd->vthis);
Logger::println("Indexing to 'this'");
#if DMDV2
if (cd->isStructDeclaration())
src = DtoExtractValue(thisval, cd->vthis->ir.irField->index, ".vthis");
else
#endif
src = DtoLoad(DtoGEPi(thisval, 0, cd->vthis->ir.irField->index, ".vthis"));
} else {
src = DtoLoad(src);
}
if (depth > 1) {
src = DtoBitCast(src, getVoidPtrType());
LLValue* dst = DtoBitCast(frame, getVoidPtrType());
DtoMemCpy(dst, src, DtoConstSize_t((depth-1) * PTRSIZE),
getABITypeAlign(getVoidPtrType()));
}
// Copy nestArg into framelist; the outer frame is not in the list of pointers
src = DtoBitCast(src, frameType->getContainedType(depth-1));
LLValue* gep = DtoGEPi(frame, 0, depth-1);
DtoAlignedStore(src, gep);
}
// store context in IrFunction
irfunction->nestedVar = frame;
// go through all nested vars and assign addresses where possible.
for (std::set<VarDeclaration*>::iterator i=fd->nestedVars.begin(); i!=fd->nestedVars.end(); ++i)
{
VarDeclaration* vd = *i;
LLValue* gep = DtoGEPi(frame, 0, vd->ir.irLocal->nestedIndex, vd->toChars());
if (vd->isParameter()) {
Logger::println("nested param: %s", vd->toChars());
LOG_SCOPE
LLValue* value = vd->ir.irLocal->value;
if (llvm::isa<llvm::AllocaInst>(llvm::GetUnderlyingObject(value))) {
Logger::println("Copying to nested frame");
// The parameter value is an alloca'd stack slot.
// Copy to the nesting frame and leave the alloca for
// the optimizers to clean up.
assert(!vd->ir.irLocal->byref);
DtoStore(DtoLoad(value), gep);
gep->takeName(value);
vd->ir.irLocal->value = gep;
} else {
Logger::println("Adding pointer to nested frame");
// The parameter value is something else, such as a
// passed-in pointer (for 'ref' or 'out' parameters) or
// a pointer arg with byval attribute.
// Store the address into the frame.
assert(vd->ir.irLocal->byref);
storeVariable(vd, gep);
}
} else if (vd->isRef() || vd->isOut()) {
// This slot is initialized in DtoNestedInit, to handle things like byref foreach variables
// which move around in memory.
assert(vd->ir.irLocal->byref);
} else {
Logger::println("nested var: %s", vd->toChars());
if (vd->ir.irLocal->value)
Logger::cout() << "Pre-existing value: " << *vd->ir.irLocal->value << '\n';
assert(!vd->ir.irLocal->value);
vd->ir.irLocal->value = gep;
assert(!vd->ir.irLocal->byref);
}
if (global.params.symdebug) {
LLSmallVector<LLValue*, 2> addr;
dwarfOpOffset(addr, frameType, vd->ir.irLocal->nestedIndex);
DtoDwarfLocalVariable(frame, vd, addr);
}
}
} else if (FuncDeclaration* parFunc = getParentFunc(fd, true)) {
// Propagate context arg properties if the context arg is passed on unmodified.
DtoDeclareFunction(parFunc);
fd->ir.irFunc->frameType = parFunc->ir.irFunc->frameType;
fd->ir.irFunc->depth = parFunc->ir.irFunc->depth;
}
}
else {
assert(0 && "Not implemented yet");
}
}